@elizaos/core 1.0.0-beta.5 → 1.0.0-beta.50

package/dist/instrumentation/index.d.ts

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

package/dist/instrumentation/service.d.ts

@@ -0,0 +1,21 @@
+import { Tracer, Meter } from '@opentelemetry/api';
+import { IInstrumentationService, InstrumentationConfig } from './types';
+import { Service, IAgentRuntime } from '../types';
+export 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>;
+}

package/dist/instrumentation/types.d.ts

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

package/dist/prompts.d.ts

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

package/dist/roles.d.ts

@@ -2,6 +2,10 @@ import { type IAgentRuntime, Role, type World } from './types';
 /**
  * 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.
+ */
 export interface ServerOwnershipState {
     servers: {
         [serverId: string]: World;
@@ -22,4 +26,4 @@ export declare function getUserServerRole(runtime: IAgentRuntime, entityId: stri
 /**
  * Finds a server where the given user is the owner
  */
-export declare function findWorldForOwner(runtime: IAgentRuntime, entityId: string): Promise<World | null>;
+export declare function findWorldsForOwner(runtime: IAgentRuntime, entityId: string): Promise<World[] | null>;

package/dist/runtime.d.ts

@@ -1,17 +1,9 @@
-import { ChannelType } from './types';
-import type { Action, Agent, Character, Component, Entity, Evaluator, HandlerCallback, IAgentRuntime, IDatabaseAdapter, KnowledgeItem, Log, Memory, MemoryMetadata, ModelParamsMap, ModelResultMap, ModelTypeName, Participant, Plugin, Provider, Relationship, Room, Route, Service, ServiceTypeName, State, Task, TaskWorker, UUID, World } from './types';
-/**
- * Interface for settings object with key-value pairs.
- */
-interface Settings {
-    [key: string]: string | undefined;
-}
-/**
- * Loads environment variables from the nearest .env file in Node.js
- * or returns configured settings in browser
- * @returns {Settings} Environment variables object
- */
-export declare function loadEnvConfig(): Settings;
+import { type Context, type Span } from '@opentelemetry/api';
+import { InstrumentationService } from './instrumentation/service';
+import { ChannelType, type Content } from './types';
+import type { Action, Agent, Character, Component, Entity, Evaluator, HandlerCallback, IAgentRuntime, IDatabaseAdapter, KnowledgeItem, Log, Memory, MemoryMetadata, ModelParamsMap, ModelResultMap, ModelTypeName, Participant, Plugin, Provider, Relationship, Room, Route, RuntimeSettings, Service, ServiceTypeName, State, Task, TaskWorker, UUID, World, TargetInfo, SendHandlerFunction, ModelHandler } from './types';
+import { PGlite } from '@electric-sql/pglite';
+import { Pool } from 'pg';
 export declare class Semaphore {
     private permits;
     private waiting;
@@ -20,21 +12,11 @@ export declare class Semaphore {
     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.
+ * AgentRuntime provides the core runtime environment and lifecycle management for agents.
+ *
+ * Implements the IAgentRuntime interface, managing agent state, actions, plugins, providers, and database interaction.
+ *
+ * implements IAgentRuntime
  */
 export declare class AgentRuntime implements IAgentRuntime {
     #private;
@@ -45,6 +27,7 @@ export declare class AgentRuntime implements IAgentRuntime {
     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: {
@@ -57,13 +40,17 @@ export declare class AgentRuntime implements IAgentRuntime {
     }>;
     readonly fetch: typeof fetch;
     services: Map<ServiceTypeName, Service>;
-    models: Map<string, ((runtime: IAgentRuntime, params: any) => Promise<any>)[]>;
+    models: Map<string, ModelHandler[]>;
     routes: Route[];
     private taskWorkers;
+    private sendHandlers;
     private eventHandlers;
     private runtimeLogger;
     private knowledgeProcessingSemaphore;
     private settings;
+    private servicesInitQueue;
+    instrumentationService: InstrumentationService;
+    tracer: any;
     constructor(opts: {
         conversationLength?: number;
         agentId?: UUID;
@@ -71,11 +58,31 @@ export declare class AgentRuntime implements IAgentRuntime {
         plugins?: Plugin[];
         fetch?: typeof fetch;
         adapter?: IDatabaseAdapter;
+        settings?: RuntimeSettings;
         events?: {
             [key: string]: ((params: any) => void)[];
         };
-        ignoreBootstrap?: boolean;
     });
+    /**
+     * 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
@@ -84,13 +91,22 @@ export declare class AgentRuntime implements IAgentRuntime {
     getAllServices(): Map<ServiceTypeName, Service>;
     stop(): Promise<void>;
     initialize(): Promise<void>;
+    getConnection(): Promise<PGlite | Pool>;
     private handleProcessingError;
     private checkExistingKnowledge;
-    getKnowledge(message: Memory): Promise<KnowledgeItem[]>;
+    getKnowledge(message: Memory, scope?: {
+        roomId?: UUID;
+        worldId?: UUID;
+        entityId?: UUID;
+    }): Promise<KnowledgeItem[]>;
     addKnowledge(item: KnowledgeItem, options?: {
         targetTokens: number;
         overlap: number;
         modelContextSize: number;
+    }, scope?: {
+        roomId: `${string}-${string}-${string}-${string}-${string}`;
+        entityId: `${string}-${string}-${string}-${string}-${string}`;
+        worldId: `${string}-${string}-${string}-${string}-${string}`;
     }): Promise<void>;
     processCharacterKnowledge(items: string[]): Promise<void>;
     setSetting(key: string, value: string | boolean | null | any, secret?: boolean): void;
@@ -138,16 +154,19 @@ export declare class AgentRuntime implements IAgentRuntime {
      * @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, }: {
+    ensureConnection({ entityId, roomId, worldId, worldName, userName, name, source, type, channelId, serverId, userId, metadata, }: {
         entityId: UUID;
         roomId: UUID;
+        worldId: UUID;
+        worldName?: string;
         userName?: string;
         name?: string;
         source?: string;
         type?: ChannelType;
         channelId?: string;
         serverId?: string;
-        worldId?: UUID;
+        userId?: UUID;
+        metadata?: Record<string, any>;
     }): Promise<void>;
     /**
      * Ensures a participant is added to a room, checking that the entity exists first
@@ -173,15 +192,16 @@ export declare class AgentRuntime implements IAgentRuntime {
      * 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
+     * @param onlyInclude - If true, only include providers that are in the includeList, don't get other registered providers
+     * @param skipCache - If true, skip the cache and get the latest data from the providers
      * @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>;
+    composeState(message: Memory, includeList?: string[] | null, // include providers that are private, dynamic or otherwise not included by default
+    onlyInclude?: boolean, skipCache?: boolean): 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;
+    registerModel(modelType: ModelTypeName, handler: (params: any) => Promise<any>, provider: string, priority?: number): void;
+    getModel(modelType: ModelTypeName, provider?: string): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
     /**
      * Use a model with strongly typed parameters and return values based on model type
      * @template T - The model type to use
@@ -190,7 +210,7 @@ export declare class AgentRuntime implements IAgentRuntime {
      * @param {ModelParamsMap[T] | any} params - The parameters for the model, typed based on model type
      * @returns {Promise<R>} - The model result, typed based on the provided generic type parameter
      */
-    useModel<T extends ModelTypeName, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], 'runtime'> | any): Promise<R>;
+    useModel<T extends ModelTypeName, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], 'runtime'> | any, provider?: string): Promise<R>;
     registerEvent(event: string, handler: (params: any) => Promise<void>): void;
     getEvent(event: string): ((params: any) => Promise<void>)[] | undefined;
     emitEvent(event: string | string[], params: any): Promise<void>;
@@ -204,11 +224,11 @@ export declare class AgentRuntime implements IAgentRuntime {
     init(): Promise<void>;
     close(): Promise<void>;
     getAgent(agentId: UUID): Promise<Agent | null>;
-    getAgents(): Promise<Agent[]>;
+    getAgents(): Promise<Partial<Agent>[]>;
     createAgent(agent: Partial<Agent>): Promise<boolean>;
     updateAgent(agentId: UUID, agent: Partial<Agent>): Promise<boolean>;
     deleteAgent(agentId: UUID): Promise<boolean>;
-    ensureAgentExists(agent: Partial<Agent>): Promise<void>;
+    ensureAgentExists(agent: Partial<Agent>): Promise<Agent>;
     getEntityById(entityId: UUID): Promise<Entity | null>;
     getEntitiesForRoom(roomId: UUID, includeComponents?: boolean): Promise<Entity[]>;
     createEntity(entity: Entity): Promise<boolean>;
@@ -257,12 +277,16 @@ export declare class AgentRuntime implements IAgentRuntime {
     }): Promise<void>;
     searchMemories(params: {
         embedding: number[];
+        query?: string;
         match_threshold?: number;
         count?: number;
         roomId?: UUID;
         unique?: boolean;
+        worldId?: UUID;
+        entityId?: UUID;
         tableName: string;
     }): Promise<Memory[]>;
+    rerankMemories(query: string, memories: Memory[]): Promise<Memory[]>;
     createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<UUID>;
     updateMemory(memory: Partial<Memory> & {
         id: UUID;
@@ -281,11 +305,13 @@ export declare class AgentRuntime implements IAgentRuntime {
     deleteLog(logId: UUID): Promise<void>;
     createWorld(world: World): Promise<UUID>;
     getWorld(id: UUID): Promise<World | null>;
+    removeWorld(worldId: UUID): Promise<void>;
     getAllWorlds(): Promise<World[]>;
     updateWorld(world: World): Promise<void>;
     getRoom(roomId: UUID): Promise<Room | null>;
     createRoom({ id, name, source, type, channelId, serverId, worldId }: Room): Promise<UUID>;
     deleteRoom(roomId: UUID): Promise<void>;
+    deleteRoomsByServerId(serverId: UUID): Promise<void>;
     updateRoom(room: Room): Promise<void>;
     getRoomsForParticipant(entityId: UUID): Promise<UUID[]>;
     getRoomsForParticipants(userIds: UUID[]): Promise<UUID[]>;
@@ -316,6 +342,7 @@ export declare class AgentRuntime implements IAgentRuntime {
     getTasks(params: {
         roomId?: UUID;
         tags?: string[];
+        entityId?: UUID;
     }): Promise<Task[]>;
     getTask(id: UUID): Promise<Task | null>;
     getTasksByName(name: string): Promise<Task[]>;
@@ -324,5 +351,29 @@ export declare class AgentRuntime implements IAgentRuntime {
     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>;
+    /**
+     * Registers a handler function for sending messages to a specific source.
+     * @param source - The unique identifier for the source.
+     * @param handler - The SendHandlerFunction to register.
+     */
+    registerSendHandler(source: string, handler: SendHandlerFunction): void;
+    /**
+     * Sends a message to a target using the registered handler for the target's source.
+     * @param target - Information about the message target.
+     * @param content - The message content.
+     */
+    sendMessageToTarget(target: TargetInfo, content: Content): Promise<void>;
 }
-export {};