@elizaos/core 1.3.1 → 1.4.2

package/dist/types-DIUaglro.d.ts

@@ -1,1964 +0,0 @@
-/**
- * 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;
-/**
- * Defines the recognized types of models that the agent runtime can use.
- * These include models for text generation (small, large, reasoning, completion),
- * text embedding, tokenization (encode/decode), image generation and description,
- * audio transcription, text-to-speech, and generic object generation.
- * This constant is used throughout the system, particularly in `AgentRuntime.useModel`,
- * `AgentRuntime.registerModel`, and in `ModelParamsMap` / `ModelResultMap` to ensure
- * type safety and clarity when working with different AI models.
- * String values are used for extensibility with custom model types.
- */
-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";
-};
-/**
- * Core service type registry that can be extended by plugins via module augmentation.
- * Plugins can extend this interface to add their own service types:
- *
- * @example
- * ```typescript
- * declare module '@elizaos/core' {
- *   interface ServiceTypeRegistry {
- *     MY_CUSTOM_SERVICE: 'my_custom_service';
- *   }
- * }
- * ```
- */
-interface ServiceTypeRegistry {
-    TRANSCRIPTION: 'transcription';
-    VIDEO: 'video';
-    BROWSER: 'browser';
-    PDF: 'pdf';
-    REMOTE_FILES: 'aws_s3';
-    WEB_SEARCH: 'web_search';
-    EMAIL: 'email';
-    TEE: 'tee';
-    TASK: 'task';
-}
-/**
- * Type for service names that includes both core services and any plugin-registered services
- */
-type ServiceTypeName = ServiceTypeRegistry[keyof ServiceTypeRegistry];
-/**
- * Helper type to extract service type values from the registry
- */
-type ServiceTypeValue<K extends keyof ServiceTypeRegistry> = ServiceTypeRegistry[K];
-/**
- * Helper type to check if a service type exists in the registry
- */
-type IsValidServiceType<T extends string> = T extends ServiceTypeName ? true : false;
-/**
- * Type-safe service class definition
- */
-type TypedServiceClass<T extends ServiceTypeName> = {
-    new (runtime?: IAgentRuntime): Service;
-    serviceType: T;
-    start(runtime: IAgentRuntime): Promise<Service>;
-};
-/**
- * Map of service type names to their implementation classes
- */
-interface ServiceClassMap {
-}
-/**
- * Helper to infer service instance type from service type name
- */
-type ServiceInstance<T extends ServiceTypeName> = T extends keyof ServiceClassMap ? InstanceType<ServiceClassMap[T]> : Service;
-/**
- * Runtime service registry type
- */
-type ServiceRegistry<T extends ServiceTypeName = ServiceTypeName> = Map<T, Service>;
-/**
- * Enumerates the recognized types of services that can be registered and used by the agent runtime.
- * Services provide specialized functionalities like audio transcription, video processing,
- * web browsing, PDF handling, file storage (e.g., AWS S3), web search, email integration,
- * secure execution via TEE (Trusted Execution Environment), and task management.
- * This constant is used in `AgentRuntime` for service registration and retrieval (e.g., `getService`).
- * Each service typically implements the `Service` abstract class or a more specific interface like `IVideoService`.
- */
-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";
-};
-/**
- * Represents the current state or context of a conversation or agent interaction.
- * This interface is a flexible container for various pieces of information that define the agent's
- * understanding at a point in time. It includes:
- * - `values`: A key-value store for general state variables, often populated by providers.
- * - `data`: Another key-value store, potentially for more structured or internal data.
- * - `text`: A string representation of the current context, often a summary or concatenated history.
- * The `[key: string]: any;` allows for dynamic properties, though `EnhancedState` offers better typing.
- * This state object is passed to handlers for actions, evaluators, and providers.
- */
-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;
-/**
- * Enumerates the built-in types of memories that can be stored and retrieved.
- * - `DOCUMENT`: Represents a whole document or a large piece of text.
- * - `FRAGMENT`: A chunk or segment of a `DOCUMENT`, often created for embedding and search.
- * - `MESSAGE`: A conversational message, typically from a user or the agent.
- * - `DESCRIPTION`: A descriptive piece of information, perhaps about an entity or concept.
- * - `CUSTOM`: For any other type of memory not covered by the built-in types.
- * This enum is used in `MemoryMetadata` to categorize memories and influences how they are processed or queried.
- */
-declare enum MemoryType {
-    DOCUMENT = "document",
-    FRAGMENT = "fragment",
-    MESSAGE = "message",
-    DESCRIPTION = "description",
-    CUSTOM = "custom"
-}
-/**
- * Defines the scope of a memory, indicating its visibility and accessibility.
- * - `shared`: The memory is accessible to multiple entities or across different contexts (e.g., a public fact).
- * - `private`: The memory is specific to a single entity or a private context (e.g., a user's personal preference).
- * - `room`: The memory is scoped to a specific room or channel.
- * This is used in `MemoryMetadata` to control how memories are stored and retrieved based on context.
- */
-type MemoryScope = 'shared' | 'private' | 'room';
-/**
- * Base interface for all memory metadata types.
- * It includes common properties for all memories, such as:
- * - `type`: The kind of memory (e.g., `MemoryType.MESSAGE`, `MemoryType.DOCUMENT`).
- * - `source`: An optional string indicating the origin of the memory (e.g., 'discord', 'user_input').
- * - `sourceId`: An optional UUID linking to a source entity or object.
- * - `scope`: The visibility scope of the memory (`shared`, `private`, or `room`).
- * - `timestamp`: An optional numerical timestamp (e.g., milliseconds since epoch) of when the memory was created or relevant.
- * - `tags`: Optional array of strings for categorizing or filtering memories.
- * Specific metadata types like `DocumentMetadata` or `MessageMetadata` extend this base.
- */
-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;
-    /** Associated world ID (optional) */
-    worldId?: 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;
-    createdAt: number;
-    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 RoomMetadata = {
-    [key: string]: unknown;
-};
-type Room = {
-    id: UUID;
-    name?: string;
-    agentId?: UUID;
-    source: string;
-    type: ChannelType;
-    channelId?: string;
-    serverId?: string;
-    worldId?: UUID;
-    metadata?: RoomMetadata;
-};
-/**
- * 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?: ContentType;
-};
-declare enum ContentType {
-    IMAGE = "image",
-    VIDEO = "video",
-    AUDIO = "audio",
-    DOCUMENT = "document",
-    LINK = "link"
-}
-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"
-}
-type Route = {
-    type: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'STATIC';
-    path: string;
-    filePath?: string;
-    public?: boolean;
-    name?: string extends {
-        public: true;
-    } ? string : string | undefined;
-    handler?: (req: any, res: any, runtime: IAgentRuntime) => Promise<void>;
-    isMultipart?: boolean;
-};
-/**
- * Plugin for extending agent functionality
- */
-type PluginEvents = {
-    [K in keyof EventPayloadMap]?: EventHandler<K>[];
-} & {
-    [key: string]: ((params: EventPayload) => Promise<any>)[];
-};
-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?: PluginEvents;
-    routes?: Route[];
-    tests?: TestSuite[];
-    dependencies?: string[];
-    priority?: number;
-}
-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's character, defining its personality, knowledge, and capabilities.
- * This is a central piece of an agent's definition, used by the `AgentRuntime` to initialize and operate the agent.
- * It includes:
- * - `id`: Optional unique identifier for the character.
- * - `name`, `username`: Identifying names for the character.
- * - `system`: A system prompt that guides the agent's overall behavior.
- * - `templates`: A map of prompt templates for various situations (e.g., message generation, summarization).
- * - `bio`: A textual biography or description of the character.
- * - `messageExamples`, `postExamples`: Examples of how the character communicates.
- * - `topics`, `adjectives`: Keywords describing the character's knowledge areas and traits.
- * - `knowledge`: Paths to knowledge files or directories to be loaded into the agent's memory.
- * - `plugins`: A list of plugin names to be loaded for this character.
- * - `settings`, `secrets`: Configuration key-value pairs, with secrets being handled more securely.
- * - `style`: Guidelines for the character's writing style in different contexts (chat, post).
- */
-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"
-}
-/**
- * Represents an operational agent, extending the `Character` definition with runtime status and timestamps.
- * While `Character` defines the blueprint, `Agent` represents an instantiated and potentially running version.
- * It includes:
- * - `enabled`: A boolean indicating if the agent is currently active or disabled.
- * - `status`: The current operational status, typically `AgentStatus.ACTIVE` or `AgentStatus.INACTIVE`.
- * - `createdAt`, `updatedAt`: Timestamps for when the agent record was created and last updated in the database.
- * This interface is primarily used by the `IDatabaseAdapter` for agent management.
- */
-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>;
-    getConnection(): Promise<any>;
-    getAgent(agentId: UUID): Promise<Agent | null>;
-    /** Get all agents */
-    getAgents(): Promise<Partial<Agent>[]>;
-    createAgent(agent: Partial<Agent>): Promise<boolean>;
-    updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
-    deleteAgent(agentId: UUID): Promise<boolean>;
-    ensureEmbeddingDimension(dimension: number): Promise<void>;
-    /** Get entity by IDs */
-    getEntitiesByIds(entityIds: UUID[]): Promise<Entity[] | null>;
-    /** Get entities for room */
-    getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
-    /** Create new entities */
-    createEntities(entities: 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;
-        count?: number;
-        unique?: boolean;
-        tableName: string;
-        start?: number;
-        end?: number;
-        roomId?: UUID;
-        worldId?: UUID;
-    }): 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;
-        unique?: boolean;
-        tableName: string;
-        query?: string;
-        roomId?: UUID;
-        worldId?: UUID;
-        entityId?: UUID;
-    }): 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>;
-    deleteManyMemories(memoryIds: 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>;
-    removeWorld(id: UUID): Promise<void>;
-    getAllWorlds(): Promise<World[]>;
-    updateWorld(world: World): Promise<void>;
-    getRoomsByIds(roomIds: UUID[]): Promise<Room[] | null>;
-    createRooms(rooms: Room[]): Promise<UUID[]>;
-    deleteRoom(roomId: UUID): Promise<void>;
-    deleteRoomsByWorldId(worldId: UUID): Promise<void>;
-    updateRoom(room: Room): Promise<void>;
-    getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
-    getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
-    getRoomsByWorld(worldId: UUID): Promise<Room[]>;
-    removeParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
-    getParticipantsForEntity(entityId: UUID): Promise<Participant[]>;
-    getParticipantsForRoom(roomId: UUID): Promise<UUID[]>;
-    addParticipantsRoom(entityIds: UUID[], roomId: UUID): Promise<boolean>;
-    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[];
-        entityId?: UUID;
-    }): Promise<Task[]>;
-    getTask(id: UUID): Promise<Task | null>;
-    getTasksByName(name: string): Promise<Task[]>;
-    updateTask(id: UUID, task: Partial<Task>): Promise<void>;
-    deleteTask(id: UUID): Promise<void>;
-    getMemoriesByWorldId(params: {
-        worldId: UUID;
-        count?: number;
-        tableName?: string;
-    }): Promise<Memory[]>;
-}
-/**
- * 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;
-}
-/**
- * Information describing the target of a message.
- */
-interface TargetInfo {
-    source: string;
-    roomId?: UUID;
-    channelId?: string;
-    serverId?: string;
-    entityId?: UUID;
-    threadId?: string;
-}
-/**
- * Function signature for handlers responsible for sending messages to specific platforms.
- */
-type SendHandlerFunction = (runtime: IAgentRuntime, target: TargetInfo, content: Content) => Promise<void>;
-/**
- * Represents the core runtime environment for an agent.
- * Defines methods for database interaction, plugin management, event handling,
- * state composition, model usage, and task management.
- */
-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>;
-    getConnection(): Promise<any>;
-    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, metadata, userName, worldName, name, source, channelId, serverId, type, worldId, userId, }: {
-        entityId: UUID;
-        roomId: UUID;
-        userName?: string;
-        name?: string;
-        worldName?: string;
-        source?: string;
-        channelId?: string;
-        serverId?: string;
-        type: ChannelType;
-        worldId: UUID;
-        userId?: UUID;
-        metadata?: Record<string, any>;
-    }): Promise<void>;
-    ensureParticipantInRoom(entityId: UUID, roomId: UUID): Promise<void>;
-    ensureWorldExists(world: World): Promise<void>;
-    ensureRoomExists(room: Room): Promise<void>;
-    composeState(message: Memory, includeList?: string[], onlyInclude?: boolean, skipCache?: boolean): 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>, provider: string, priority?: number): 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>;
-    getAllMemories(): Promise<Memory[]>;
-    clearAllAgentMemories(): Promise<void>;
-    createRunId(): UUID;
-    startRun(): UUID;
-    endRun(): void;
-    getCurrentRunId(): UUID;
-    getEntityById(entityId: UUID): Promise<Entity | null>;
-    getRoom(roomId: UUID): Promise<Room | null>;
-    createEntity(entity: Entity): Promise<boolean>;
-    createRoom({ id, name, source, type, channelId, serverId, worldId }: Room): Promise<UUID>;
-    addParticipant(entityId: UUID, roomId: UUID): Promise<boolean>;
-    getRooms(worldId: UUID): Promise<Room[]>;
-    /**
-     * Registers a handler function responsible for sending messages to a specific source/platform.
-     * @param source - The unique identifier string for the source (e.g., 'discord', 'telegram').
-     * @param handler - The SendHandlerFunction to be called for this source.
-     */
-    registerSendHandler(source: string, handler: SendHandlerFunction): void;
-    /**
-     * Sends a message to a specified target using the appropriate registered handler.
-     * @param target - Information describing the target recipient and platform.
-     * @param content - The message content to send.
-     * @returns Promise resolving when the message sending process is initiated or completed.
-     */
-    sendMessageToTarget(target: TargetInfo, content: Content): Promise<void>;
-}
-/**
- * Interface for settings object with key-value pairs.
- */
-/**
- * Interface representing settings with string key-value pairs.
- */
-interface RuntimeSettings {
-    [key: string]: string | undefined;
-}
-/**
- * Represents a single item of knowledge that can be processed and stored by the agent.
- * Knowledge items consist of content (text and optional structured data) and metadata.
- * These items are typically added to the agent's knowledge base via `AgentRuntime.addKnowledge`
- * and retrieved using `AgentRuntime.getKnowledge`.
- * The `id` is a unique identifier for the knowledge item, often derived from its source or content.
- */
-type KnowledgeItem = {
-    /** A Universally Unique Identifier for this specific knowledge item. */
-    id: UUID;
-    /** The actual content of the knowledge item, which must include text and can have other fields. */
-    content: Content;
-    /** Optional metadata associated with this knowledge item, conforming to `MemoryMetadata`. */
-    metadata?: MemoryMetadata;
-};
-/**
- * Defines the scope or visibility of knowledge items within the agent's system.
- * - `SHARED`: Indicates knowledge that is broadly accessible, potentially across different agents or users if the system architecture permits.
- * - `PRIVATE`: Indicates knowledge that is restricted, typically to the specific agent or user context it belongs to.
- * This enum is used to manage access and retrieval of knowledge items, often in conjunction with `AgentRuntime.addKnowledge` or `AgentRuntime.getKnowledge` scopes.
- */
-declare enum KnowledgeScope {
-    SHARED = "shared",
-    PRIVATE = "private"
-}
-/**
- * Specifies prefixes for keys used in caching mechanisms, helping to namespace cached data.
- * For example, `KNOWLEDGE` might be used to prefix keys for cached knowledge embeddings or processed documents.
- * This helps in organizing the cache and avoiding key collisions.
- * Used internally by caching strategies, potentially within `IDatabaseAdapter` cache methods or runtime caching layers.
- */
-declare enum CacheKeyPrefix {
-    KNOWLEDGE = "knowledge"
-}
-/**
- * Represents an item within a directory listing, specifically for knowledge loading.
- * When an agent's `Character.knowledge` configuration includes a directory, this type
- * is used to specify the path to that directory and whether its contents should be treated as shared.
- * - `directory`: The path to the directory containing knowledge files.
- * - `shared`: An optional boolean (defaults to false) indicating if the knowledge from this directory is considered shared or private.
- */
-interface DirectoryItem {
-    /** The path to the directory containing knowledge files. */
-    directory: string;
-    /** If true, knowledge from this directory is considered shared; otherwise, it's private. Defaults to false. */
-    shared?: boolean;
-}
-/**
- * Represents a row structure, typically from a database query related to text chunking or processing.
- * This interface is quite minimal and seems to be a placeholder or a base for more specific chunk-related types.
- * The `id` would be the unique identifier for the chunk.
- * It might be used when splitting large documents into smaller, manageable pieces for embedding or analysis.
- */
-interface ChunkRow {
-    /** The unique identifier for this chunk of text. */
-    id: string;
-}
-/**
- * Parameters for generating text using a language model.
- * This structure is typically passed to `AgentRuntime.useModel` when the `modelType` is one of
- * `ModelType.TEXT_SMALL`, `ModelType.TEXT_LARGE`, `ModelType.TEXT_REASONING_SMALL`,
- * `ModelType.TEXT_REASONING_LARGE`, or `ModelType.TEXT_COMPLETION`.
- * It includes essential information like the prompt, model type, and various generation controls.
- */
-type GenerateTextParams = {
-    /** The `AgentRuntime` instance, providing access to models and other services. */
-    runtime: IAgentRuntime;
-    /** The input string or prompt that the language model will use to generate text. */
-    prompt: string;
-    /** Specifies the type of text generation model to use (e.g., TEXT_LARGE, REASONING_SMALL). */
-    modelType: ModelTypeName;
-    /** Optional. The maximum number of tokens to generate in the response. */
-    maxTokens?: number;
-    /** Optional. Controls randomness (0.0-1.0). Lower values are more deterministic, higher are more creative. */
-    temperature?: number;
-    /** Optional. Penalizes new tokens based on their existing frequency in the text so far. */
-    frequencyPenalty?: number;
-    /** Optional. Penalizes new tokens based on whether they appear in the text so far. */
-    presencePenalty?: number;
-    /** Optional. A list of sequences at which the model will stop generating further tokens. */
-    stopSequences?: string[];
-};
-/**
- * Parameters for tokenizing text, i.e., converting a string into a sequence of numerical tokens.
- * This is a common preprocessing step for many language models.
- * This structure is used with `AgentRuntime.useModel` when the `modelType` is `ModelType.TEXT_TOKENIZER_ENCODE`.
- */
-interface TokenizeTextParams {
-    /** The input string to be tokenized. */
-    prompt: string;
-    /** The model type to use for tokenization, which determines the tokenizer algorithm and vocabulary. */
-    modelType: ModelTypeName;
-}
-/**
- * Parameters for detokenizing text, i.e., converting a sequence of numerical tokens back into a string.
- * This is the reverse operation of tokenization.
- * This structure is used with `AgentRuntime.useModel` when the `modelType` is `ModelType.TEXT_TOKENIZER_DECODE`.
- */
-interface DetokenizeTextParams {
-    /** An array of numerical tokens to be converted back into text. */
-    tokens: number[];
-    /** The model type used for detokenization, ensuring consistency with the original tokenization. */
-    modelType: ModelTypeName;
-}
-/**
- * Represents a test case for evaluating agent or plugin functionality.
- * Each test case has a name and a function that contains the test logic.
- * The test function receives the `IAgentRuntime` instance, allowing it to interact with the agent's capabilities.
- * Test cases are typically grouped into `TestSuite`s.
- */
-interface TestCase {
-    /** A descriptive name for the test case, e.g., "should respond to greetings". */
-    name: string;
-    /**
-     * The function that executes the test logic. It can be synchronous or asynchronous.
-     * It receives the `IAgentRuntime` to interact with the agent and its services.
-     * The function should typically contain assertions to verify expected outcomes.
-     */
-    fn: (runtime: IAgentRuntime) => Promise<void> | void;
-}
-/**
- * Represents a suite of related test cases for an agent or plugin.
- * This helps in organizing tests and running them collectively.
- * A `ProjectAgent` can define one or more `TestSuite`s.
- */
-interface TestSuite {
-    /** A descriptive name for the test suite, e.g., "Core Functionality Tests". */
-    name: string;
-    /** An array of `TestCase` objects that belong to this suite. */
-    tests: TestCase[];
-}
-/**
- * Represents an agent's registration details within a Trusted Execution Environment (TEE) context.
- * This is typically stored in a database table (e.g., `TeeAgent`) to manage agents operating in a TEE.
- * It allows for multiple registrations of the same `agentId` to support scenarios where an agent might restart,
- * generating a new keypair and attestation each time.
- */
-interface TeeAgent {
-    /** Primary key for the TEE agent registration record (e.g., a UUID or auto-incrementing ID). */
-    id: string;
-    /** The core identifier of the agent, which can be duplicated across multiple TEE registrations. */
-    agentId: string;
-    /** The human-readable name of the agent. */
-    agentName: string;
-    /** Timestamp (e.g., Unix epoch in milliseconds) when this TEE registration was created. */
-    createdAt: number;
-    /** The public key associated with this specific TEE agent instance/session. */
-    publicKey: string;
-    /** The attestation document proving the authenticity and integrity of the TEE instance. */
-    attestation: string;
-}
-/**
- * Defines the operational modes for a Trusted Execution Environment (TEE).
- * This enum is used to configure how TEE functionalities are engaged, allowing for
- * different setups for local development, Docker-based development, and production.
- */
-declare enum TEEMode {
-    /** TEE functionality is completely disabled. */
-    OFF = "OFF",
-    /** For local development, potentially using a TEE simulator. */
-    LOCAL = "LOCAL",// For local development with simulator
-    /** For Docker-based development environments, possibly with a TEE simulator. */
-    DOCKER = "DOCKER",// For docker development with simulator
-    /** For production deployments, using actual TEE hardware without a simulator. */
-    PRODUCTION = "PRODUCTION"
-}
-/**
- * Represents a quote obtained during remote attestation for a Trusted Execution Environment (TEE).
- * This quote is a piece of evidence provided by the TEE, cryptographically signed, which can be
- * verified by a relying party to ensure the TEE's integrity and authenticity.
- */
-interface RemoteAttestationQuote {
-    /** The attestation quote data, typically a base64 encoded string or similar format. */
-    quote: string;
-    /** Timestamp (e.g., Unix epoch in milliseconds) when the quote was generated or received. */
-    timestamp: number;
-}
-/**
- * Data structure used in the attestation process for deriving a key within a Trusted Execution Environment (TEE).
- * This information helps establish a secure channel or verify the identity of the agent instance
- * requesting key derivation.
- */
-interface DeriveKeyAttestationData {
-    /** The unique identifier of the agent for which the key derivation is being attested. */
-    agentId: string;
-    /** The public key of the agent instance involved in the key derivation process. */
-    publicKey: string;
-    /** Optional subject or context information related to the key derivation. */
-    subject?: string;
-}
-/**
- * Represents a message that has been attested by a Trusted Execution Environment (TEE).
- * This structure binds a message to an agent's identity and a timestamp, all within the
- * context of a remote attestation process, ensuring the message originated from a trusted TEE instance.
- */
-interface RemoteAttestationMessage {
-    /** The unique identifier of the agent sending the attested message. */
-    agentId: string;
-    /** Timestamp (e.g., Unix epoch in milliseconds) when the message was attested or sent. */
-    timestamp: number;
-    /** The actual message content, including details about the entity, room, and the content itself. */
-    message: {
-        entityId: string;
-        roomId: string;
-        content: string;
-    };
-}
-/**
- * Enumerates different types or vendors of Trusted Execution Environments (TEEs).
- * This allows the system to adapt to specific TEE technologies, like Intel TDX on DSTACK.
- */
-declare enum TeeType {
-    /** Represents Intel Trusted Domain Extensions (TDX) running on DSTACK infrastructure. */
-    TDX_DSTACK = "tdx_dstack"
-}
-/**
- * Configuration options specific to a particular Trusted Execution Environment (TEE) vendor.
- * This allows for vendor-specific settings to be passed to the TEE plugin or service.
- * The structure is a generic key-value map, as configurations can vary widely between vendors.
- */
-interface TeeVendorConfig {
-    [key: string]: unknown;
-}
-/**
- * Configuration for a TEE (Trusted Execution Environment) plugin.
- * This allows specifying the TEE vendor and any vendor-specific configurations.
- * It's used to initialize and configure TEE-related functionalities within the agent system.
- */
-interface TeePluginConfig {
-    /** Optional. The name or identifier of the TEE vendor (e.g., 'tdx_dstack' from `TeeType`). */
-    vendor?: string;
-    /** Optional. Vendor-specific configuration options, conforming to `TeeVendorConfig`. */
-    vendorConfig?: TeeVendorConfig;
-}
-/**
- * Defines the contract for a Task Worker, which is responsible for executing a specific type of task.
- * Task workers are registered with the `AgentRuntime` and are invoked when a `Task` of their designated `name` needs processing.
- * This pattern allows for modular and extensible background task processing.
- */
-interface TaskWorker {
-    /** The unique name of the task type this worker handles. This name links `Task` instances to this worker. */
-    name: string;
-    /**
-     * The core execution logic for the task. This function is called by the runtime when a task needs to be processed.
-     * It receives the `AgentRuntime`, task-specific `options`, and the `Task` object itself.
-     */
-    execute: (runtime: IAgentRuntime, options: {
-        [key: string]: unknown;
-    }, task: Task) => Promise<void>;
-    /**
-     * Optional validation function that can be used to determine if a task is valid or should be executed,
-     * often based on the current message and state. This might be used by an action or evaluator
-     * before creating or queueing a task.
-     */
-    validate?: (runtime: IAgentRuntime, message: Memory, state: State) => Promise<boolean>;
-}
-/**
- * Defines metadata associated with a `Task`.
- * This can include scheduling information like `updateInterval` or UI-related details
- * for presenting task options to a user.
- * The `[key: string]: unknown;` allows for additional, unspecified metadata fields.
- */
-type TaskMetadata = {
-    /** Optional. If the task is recurring, this specifies the interval in milliseconds between updates or executions. */
-    updateInterval?: number;
-    /** Optional. Describes options or parameters that can be configured for this task, often for UI presentation. */
-    options?: {
-        name: string;
-        description: string;
-    }[];
-    /** Allows for other dynamic metadata properties related to the task. */
-    [key: string]: unknown;
-};
-/**
- * Represents a task to be performed, often in the background or at a later time.
- * Tasks are managed by the `AgentRuntime` and processed by registered `TaskWorker`s.
- * They can be associated with a room, world, and tagged for categorization and retrieval.
- * The `IDatabaseAdapter` handles persistence of task data.
- */
-interface Task {
-    /** Optional. A Universally Unique Identifier for the task. Generated if not provided. */
-    id?: UUID;
-    /** The name of the task, which should correspond to a registered `TaskWorker.name`. */
-    name: string;
-    /** Optional. Timestamp of the last update to this task. */
-    updatedAt?: number;
-    /** Optional. Metadata associated with the task, conforming to `TaskMetadata`. */
-    metadata?: TaskMetadata;
-    /** A human-readable description of what the task does or its purpose. */
-    description: string;
-    /** Optional. The UUID of the room this task is associated with. */
-    roomId?: UUID;
-    /** Optional. The UUID of the world this task is associated with. */
-    worldId?: UUID;
-    entityId?: UUID;
-    tags: string[];
-}
-/**
- * Defines roles within a system, typically for access control or permissions, often within a `World`.
- * - `OWNER`: Represents the highest level of control, typically the creator or primary administrator.
- * - `ADMIN`: Represents administrative privileges, usually a subset of owner capabilities.
- * - `NONE`: Indicates no specific role or default, minimal permissions.
- * These roles are often used in `World.metadata.roles` to assign roles to entities.
- */
-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;
-}
-/**
- * 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",
-    MESSAGE_DELETED = "MESSAGE_DELETED",
-    CHANNEL_CLEARED = "CHANNEL_CLEARED",
-    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 channel cleared events
- */
-interface ChannelClearedPayload extends EventPayload {
-    roomId: UUID;
-    channelId: string;
-    memoryCount: number;
-}
-/**
- * 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.MESSAGE_DELETED]: 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;
-    [EventType.CHANNEL_CLEARED]: ChannelClearedPayload;
-}
-/**
- * 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 extends {
-    [key: string]: any;
-} = {
-    [key: string]: any;
-}, 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;
-}
-/**
- * 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
- */
-/**
- * Defines the possible primitive types or structured types for a value within the agent's state.
- * This type is used to provide more specific typing for properties within `StateObject` and `StateArray`,
- * moving away from a generic 'any' type for better type safety and clarity in state management.
- */
-type StateValue = string | number | boolean | null | StateObject | StateArray;
-/**
- * Represents a generic object structure within the agent's state, where keys are strings
- * and values can be any `StateValue`. This allows for nested objects within the state.
- * It's a fundamental part of the `EnhancedState` interface.
- */
-interface StateObject {
-    [key: string]: StateValue;
-}
-/**
- * Represents an array of `StateValue` types within the agent's state.
- * This allows for lists of mixed or uniform types to be stored in the state,
- * contributing to the structured definition of `EnhancedState`.
- */
-type StateArray = StateValue[];
-/**
- * Enhanced State interface with more specific types for its core properties.
- * This interface provides a more structured representation of an agent's conversational state,
- * building upon the base `State` by typing `values` and `data` as `StateObject`.
- * The `text` property typically holds a textual summary or context derived from the state.
- * Additional dynamic properties are still allowed via the index signature `[key: string]: StateValue;`.
- */
-interface EnhancedState {
-    /** Holds directly accessible state values, often used for template rendering or quick lookups. */
-    values: StateObject;
-    /** Stores more complex or structured data, potentially namespaced by providers or internal systems. */
-    data: StateObject;
-    /** A textual representation or summary of the current state, often used as context for models. */
-    text: string;
-    /** Allows for additional dynamic properties to be added to the state object. */
-    [key: string]: StateValue;
-}
-/**
- * A generic type for the `data` field within a `Component`.
- * While `Record<string, unknown>` allows for flexibility, developers are encouraged
- * to define more specific types for component data where possible to improve type safety
- * and code maintainability. This type serves as a base for various component implementations.
- */
-type ComponentData = Record<string, unknown>;
-/**
- * Represents a generic data object that can be passed as a payload in an event.
- * This type is often used in `TypedEventHandler` to provide a flexible yet somewhat
- * structured way to handle event data. Specific event handlers might cast this to a
- * more concrete type based on the event being processed.
- */
-type EventDataObject = Record<string, unknown>;
-/**
- * Defines a more specific type for event handlers, expecting an `EventDataObject`.
- * This aims to improve upon generic 'any' type handlers, providing a clearer contract
- * for functions that respond to events emitted within the agent runtime (see `emitEvent` in `AgentRuntime`).
- * Handlers can be synchronous or asynchronous.
- */
-type TypedEventHandler = (data: EventDataObject) => Promise<void> | void;
-/**
- * Represents a generic database connection object.
- * The actual type of this connection will depend on the specific database adapter implementation
- * (e.g., a connection pool object for PostgreSQL, a client instance for a NoSQL database).
- * This `unknown` type serves as a placeholder in the abstract `IDatabaseAdapter`.
- */
-type DbConnection = unknown;
-/**
- * A generic type for metadata objects, often used in various parts of the system like
- * `Relationship` metadata or other extensible data structures.
- * It allows for arbitrary key-value pairs where values are of `unknown` type,
- * encouraging consumers to perform type checking or casting.
- */
-type MetadataObject = Record<string, unknown>;
-/**
- * Defines the structure for a model handler registration within the `AgentRuntime`.
- * Each model (e.g., for text generation, embedding) is associated with a handler function,
- * the name of the provider (plugin or system) that registered it, and an optional priority.
- * The `priority` (higher is more preferred) helps in selecting which handler to use if multiple
- * handlers are registered for the same model type. The `registrationOrder` (not in type, but used in runtime)
- * serves as a tie-breaker. See `AgentRuntime.registerModel` and `AgentRuntime.getModel`.
- */
-interface ModelHandler {
-    /** The function that executes the model, taking runtime and parameters, and returning a Promise. */
-    handler: (runtime: IAgentRuntime, params: Record<string, unknown>) => Promise<unknown>;
-    /** The name of the provider (e.g., plugin name) that registered this model handler. */
-    provider: string;
-    /**
-     * Optional priority for this model handler. Higher numbers indicate higher priority.
-     * This is used by `AgentRuntime.getModel` to select the most appropriate handler
-     * when multiple are available for a given model type. Defaults to 0 if not specified.
-     */
-    priority?: number;
-    registrationOrder?: number;
-}
-/**
- * A generic type for service configurations.
- * Services (like `IVideoService`, `IBrowserService`) can have their own specific configuration
- * structures. This type allows for a flexible way to pass configuration objects,
- * typically used during service initialization within a plugin or the `AgentRuntime`.
- */
-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;
-}
-/**
- * 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>;
-}
-
-export { type DocumentMetadata as $, type ActionExample as A, type BaseMetadata as B, type Content as C, CacheKeyPrefix as D, type Entity as E, type ChannelClearedPayload as F, ChannelType as G, type HandlerCallback as H, type IDatabaseAdapter as I, type ChunkRow as J, type ComponentData as K, type Log as L, type Memory as M, ContentType as N, type ControlMessage as O, type Provider as P, type CustomMetadata as Q, type Room as R, type State as S, type Task as T, type UUID as U, type DbConnection as V, type World as W, type DeriveKeyAttestationData as X, type DescriptionMetadata as Y, type DetokenizeTextParams as Z, type DirectoryItem as _, type Action as a, type TeePluginConfig as a$, type EmbeddingSearchResult as a0, type EnhancedState as a1, type EntityPayload as a2, type EvaluationExample as a3, type EvaluatorEventPayload as a4, type EventDataObject as a5, type EventHandler as a6, type EventPayload as a7, type EventPayloadMap as a8, EventType as a9, type ObjectGenerationParams as aA, type OnboardingConfig as aB, PlatformPrefix as aC, type PluginEvents as aD, type Project as aE, type ProjectAgent as aF, type ProviderResult as aG, type RemoteAttestationMessage as aH, type RemoteAttestationQuote as aI, type RoomMetadata as aJ, type RunEventPayload as aK, SOCKET_MESSAGE_TYPE as aL, type ServiceClassMap as aM, type ServiceConfig as aN, type ServiceError as aO, type ServiceInstance as aP, type ServiceRegistry as aQ, ServiceType as aR, type ServiceTypeRegistry as aS, type ServiceTypeValue as aT, type Setting as aU, type StateArray as aV, type StateObject as aW, type StateValue as aX, TEEMode as aY, type TaskMetadata as aZ, type TeeAgent as a_, type FragmentMetadata as aa, type GenerateTextParams as ab, type Handler as ac, type ImageDescriptionParams as ad, type ImageGenerationParams as ae, type InvokePayload as af, type IsValidServiceType as ag, type JSONSchema as ah, type KnowledgeItem as ai, KnowledgeScope as aj, type Media as ak, type MemoryRetrievalOptions as al, type MemoryScope as am, type MemorySearchOptions as an, MemoryType as ao, type MemoryTypeAlias as ap, type MessageExample as aq, type MessageMemory as ar, type MessageMetadata as as, type MessagePayload as at, type MessageReceivedHandlerParams as au, type MetadataObject as av, type ModelEventPayload as aw, type ModelHandler as ax, ModelType as ay, type MultiRoomMemoryOptions as az, type Component as b, TeeType as b0, type TeeVendorConfig as b1, type TestCase as b2, type TestSuite as b3, type TextEmbeddingParams as b4, type TextGenerationParams as b5, type TextToSpeechParams as b6, type TokenizeTextParams as b7, type TranscriptionParams as b8, type TypedEventHandler as b9, type TypedService as ba, type TypedServiceClass as bb, type UnifiedMemoryOptions as bc, type UnifiedSearchOptions as bd, VECTOR_DIMS as be, type Validator as bf, type VideoProcessingParams as bg, type WorldPayload as bh, type WorldSettings as bi, asUUID as bj, createMessageMemory as bk, createServiceError as bl, getMemoryText as bm, getTypedService as bn, isCustomMetadata as bo, isDescriptionMetadata as bp, isDocumentMemory as bq, isDocumentMetadata as br, isFragmentMemory as bs, isFragmentMetadata as bt, isMessageMetadata as bu, type MemoryMetadata as c, type Participant as d, type Relationship as e, type Agent as f, type IAgentRuntime as g, Role as h, type ServiceTypeName as i, Service as j, type Route as k, type Character as l, type Evaluator as m, type Plugin as n, type RuntimeSettings as o, type ModelTypeName as p, type ModelResultMap as q, type ModelParamsMap as r, type TaskWorker as s, type SendHandlerFunction as t, type TargetInfo as u, type TemplateType as v, type ActionEventPayload as w, AgentStatus as x, type AudioProcessingParams as y, type BaseModelParams as z };