@elizaos/core 1.0.8 → 1.0.10

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { M as Metadata, S as Service, A as Action, I as IDatabaseAdapter, U as UUID, E as Entity, C as Component, a as Memory, L as Log, b as MemoryMetadata, W as World, R as Room, P as Participant, c as Relationship, d as Agent, T as Task, e as IAgentRuntime, f as State, g as Role, h as Character, i as Evaluator, j as Provider, k as Plugin, l as ServiceTypeName, m as ModelHandler, n as Route, o as RuntimeSettings, H as HandlerCallback, p as ChannelType, q as ModelTypeName, r as ModelResultMap, s as ModelParamsMap, t as TaskWorker, u as SendHandlerFunction, v as TargetInfo, w as Content, x as Setting, y as WorldSettings, O as OnboardingConfig, z as TemplateType, B as v2 } from './index-C7vN6HiA.js';
-export { b9 as ActionEventPayload, al as ActionExample, ak as AgentStatus, aQ as AudioProcessingParams, Z as BaseMetadata, aI as BaseModelParams, af as CacheKeyPrefix, b6 as ChannelClearedPayload, ah as ChunkRow, G as ContentType, bi as ControlMessage, a2 as CustomMetadata, a_ as DbConnection, a1 as DescriptionMetadata, aH as DetokenizeTextParams, ag as DirectoryItem, _ as DocumentMetadata, aU as EmbeddingSearchResult, Q as EnhancedState, b4 as EntityPayload, ao as EvaluationExample, ba as EvaluatorEventPayload, be as EventHandler, b2 as EventPayload, bd as EventPayloadMap, b0 as EventType, $ as FragmentMetadata, aG as GenerateTextParams, am as Handler, aN as ImageDescriptionParams, aM as ImageGenerationParams, b7 as InvokePayload, av as IsValidServiceType, aS as JSONSchema, ad as KnowledgeItem, ae as KnowledgeScope, F as Media, aV as MemoryRetrievalOptions, Y as MemoryScope, aW as MemorySearchOptions, X as MemoryType, V as MemoryTypeAlias, aj as MessageExample, a3 as MessageMemory, a0 as MessageMetadata, b5 as MessagePayload, bc as MessageReceivedHandlerParams, bb as ModelEventPayload, aF as ModelType, aX as MultiRoomMemoryOptions, aT as ObjectGenerationParams, b1 as PlatformPrefix, aq as PluginEvents, as as Project, ar as ProjectAgent, ap as ProviderResult, ai as RoomMetadata, b8 as RunEventPayload, bh as SOCKET_MESSAGE_TYPE, bl as ServiceBuilder, ax as ServiceClassMap, bn as ServiceDefinition, aD as ServiceError, ay as ServiceInstance, az as ServiceRegistry, aA as ServiceType, at as ServiceTypeRegistry, au as ServiceTypeValue, N as StateArray, K as StateObject, J as StateValue, bg as TaskMetadata, bj as TestCase, bk as TestSuite, aK as TextEmbeddingParams, aJ as TextGenerationParams, aP as TextToSpeechParams, aL as TokenizeTextParams, aO as TranscriptionParams, bf as TypedEventHandler, aB as TypedService, aw as TypedServiceClass, aY as UnifiedMemoryOptions, aZ as UnifiedSearchOptions, a$ as VECTOR_DIMS, an as Validator, aR as VideoProcessingParams, b3 as WorldPayload, D as asUUID, a4 as createMessageMemory, bm as createService, aE as createServiceError, bo as defineService, ac as getMemoryText, aC as getTypedService, a9 as isCustomMetadata, a8 as isDescriptionMetadata, aa as isDocumentMemory, a5 as isDocumentMetadata, ab as isFragmentMemory, a6 as isFragmentMetadata, a7 as isMessageMetadata } from './index-C7vN6HiA.js';
+import { M as Metadata, S as Service, T as TemplateType, a as State, b as Memory, E as Entity, I as IAgentRuntime, U as UUID, C as ContentType, c as Character, A as Action, d as IDatabaseAdapter, e as Component, L as Log, f as MemoryMetadata, W as World, R as Room, P as Participant, g as Relationship, h as Agent, i as Task, j as Role, k as Evaluator, l as Provider, m as Plugin, n as ServiceTypeName, o as ModelHandler, p as Route, q as RuntimeSettings, H as HandlerCallback, r as ChannelType, s as ModelTypeName, t as ModelResultMap, u as ModelParamsMap, v as TaskWorker, w as SendHandlerFunction, x as TargetInfo, y as Content, z as Setting, B as WorldSettings, O as OnboardingConfig, D as v2 } from './index-KbaTHD-K.js';
+export { b9 as ActionEventPayload, al as ActionExample, ak as AgentStatus, aQ as AudioProcessingParams, Z as BaseMetadata, aI as BaseModelParams, af as CacheKeyPrefix, b6 as ChannelClearedPayload, ah as ChunkRow, bi as ControlMessage, a2 as CustomMetadata, a_ as DbConnection, a1 as DescriptionMetadata, aH as DetokenizeTextParams, ag as DirectoryItem, _ as DocumentMetadata, aU as EmbeddingSearchResult, Q as EnhancedState, b4 as EntityPayload, ao as EvaluationExample, ba as EvaluatorEventPayload, be as EventHandler, b2 as EventPayload, bd as EventPayloadMap, b0 as EventType, $ as FragmentMetadata, aG as GenerateTextParams, am as Handler, aN as ImageDescriptionParams, aM as ImageGenerationParams, b7 as InvokePayload, av as IsValidServiceType, aS as JSONSchema, ad as KnowledgeItem, ae as KnowledgeScope, G as Media, aV as MemoryRetrievalOptions, Y as MemoryScope, aW as MemorySearchOptions, X as MemoryType, V as MemoryTypeAlias, aj as MessageExample, a3 as MessageMemory, a0 as MessageMetadata, b5 as MessagePayload, bc as MessageReceivedHandlerParams, bb as ModelEventPayload, aF as ModelType, aX as MultiRoomMemoryOptions, aT as ObjectGenerationParams, b1 as PlatformPrefix, aq as PluginEvents, as as Project, ar as ProjectAgent, ap as ProviderResult, ai as RoomMetadata, b8 as RunEventPayload, bh as SOCKET_MESSAGE_TYPE, bl as ServiceBuilder, ax as ServiceClassMap, bn as ServiceDefinition, aD as ServiceError, ay as ServiceInstance, az as ServiceRegistry, aA as ServiceType, at as ServiceTypeRegistry, au as ServiceTypeValue, N as StateArray, K as StateObject, J as StateValue, bg as TaskMetadata, bj as TestCase, bk as TestSuite, aK as TextEmbeddingParams, aJ as TextGenerationParams, aP as TextToSpeechParams, aL as TokenizeTextParams, aO as TranscriptionParams, bf as TypedEventHandler, aB as TypedService, aw as TypedServiceClass, aY as UnifiedMemoryOptions, aZ as UnifiedSearchOptions, a$ as VECTOR_DIMS, an as Validator, aR as VideoProcessingParams, b3 as WorldPayload, F as asUUID, a4 as createMessageMemory, bm as createService, aE as createServiceError, bo as defineService, ac as getMemoryText, aC as getTypedService, a9 as isCustomMetadata, a8 as isDescriptionMetadata, aa as isDocumentMemory, a5 as isDocumentMetadata, ab as isFragmentMemory, a6 as isFragmentMetadata, a7 as isMessageMetadata } from './index-KbaTHD-K.js';
+import { z } from 'zod';
 import * as pino from 'pino';
 import * as browser from '@sentry/browser';
 export { browser as Sentry };
 export { i as v1 } from './index-BHW44X0A.js';
-import './types-szUq9-0V.js';
+import './types-CpAVqV6l.js';
 import './specs/v1/messages.js';
 import './specs/v1/types.js';
 import 'stream';
@@ -343,6 +344,401 @@ declare abstract class ILpService extends Service {
     abstract getMarketDataForPools(poolIds: string[]): Promise<Record<string, Partial<PoolInfo>>>;
 }
 
+/**
+ * Composes a context string by replacing placeholders in a template with corresponding values from the state.
+ *
+ * This function takes a template string with placeholders in the format `{{placeholder}}` and a state object.
+ * It replaces each placeholder with the value from the state object that matches the placeholder's name.
+ * If a matching key is not found in the state object for a given placeholder, the placeholder is replaced with an empty string.
+ *
+ * @param {Object} params - The parameters for composing the context.
+ * @param {State} params.state - The state object containing values to replace the placeholders in the template.
+ * @param {TemplateType} params.template - The template string or function containing placeholders to be replaced with state values.
+ * @returns {string} The composed context string with placeholders replaced by corresponding state values.
+ *
+ * @example
+ * // Given a state object and a template
+ * const state = { userName: "Alice", userAge: 30 };
+ * const template = "Hello, {{userName}}! You are {{userAge}} years old";
+ *
+ * // Composing the context with simple string replacement will result in:
+ * // "Hello, Alice! You are 30 years old."
+ * const contextSimple = composePromptFromState({ state, template });
+ *
+ * // Using composePromptFromState with a template function for dynamic template
+ * const template = ({ state }) => {
+ * const tone = Math.random() > 0.5 ? "kind" : "rude";
+ *   return `Hello, {{userName}}! You are {{userAge}} years old. Be ${tone}`;
+ * };
+ * const contextSimple = composePromptFromState({ state, template });
+ */
+/**
+ * Function to compose a prompt using a provided template and state.
+ * It compiles the template (upgrading double braces to triple braces for non-HTML escaping)
+ * and then populates it with values from the state. Additionally, it processes the
+ * resulting string with `composeRandomUser` to replace placeholders like `{{nameX}}`.
+ *
+ * @param {Object} options - Object containing state and template information.
+ * @param {State} options.state - The state object containing values to fill the template.
+ * @param {TemplateType} options.template - The template string or function to be used for composing the prompt.
+ * @returns {string} The composed prompt output, with state values and random user names populated.
+ */
+declare const composePrompt: ({ state, template, }: {
+    state: {
+        [key: string]: string;
+    };
+    template: TemplateType;
+}) => string;
+/**
+ * Function to compose a prompt using a provided template and state.
+ *
+ * @param {Object} options - Object containing state and template information.
+ * @param {State} options.state - The state object containing values to fill the template.
+ * @param {TemplateType} options.template - The template to be used for composing the prompt.
+ * @returns {string} The composed prompt output.
+ */
+declare const composePromptFromState: ({ state, template, }: {
+    state: State;
+    template: TemplateType;
+}) => string;
+/**
+ * Adds a header to a body of text.
+ *
+ * This function takes a header string and a body string and returns a new string with the header prepended to the body.
+ * If the body string is empty, the header is returned as is.
+ *
+ * @param {string} header - The header to add to the body.
+ * @param {string} body - The body to which to add the header.
+ * @returns {string} The body with the header prepended.
+ *
+ * @example
+ * // Given a header and a body
+ * const header = "Header";
+ * const body = "Body";
+ *
+ * // Adding the header to the body will result in:
+ * // "Header\nBody"
+ * const text = addHeader(header, body);
+ */
+declare const addHeader: (header: string, body: string) => string;
+declare const formatPosts: ({ messages, entities, conversationHeader, }: {
+    messages: Memory[];
+    entities: Entity[];
+    conversationHeader?: boolean;
+}) => string;
+/**
+ * Format messages into a string
+ * @param {Object} params - The formatting parameters
+ * @param {Memory[]} params.messages - List of messages to format
+ * @param {Entity[]} params.entities - List of entities for name resolution
+ * @returns {string} Formatted message string with timestamps and user information
+ */
+declare const formatMessages: ({ messages, entities, }: {
+    messages: Memory[];
+    entities: Entity[];
+}) => string;
+declare const formatTimestamp: (messageDate: number) => string;
+/**
+ * Parses key-value pairs from a simple XML structure within a given text.
+ * It looks for an XML block (e.g., <response>...</response>) and extracts
+ * text content from direct child elements (e.g., <key>value</key>).
+ *
+ * Note: This uses regex and is suitable for simple, predictable XML structures.
+ * For complex XML, a proper parsing library is recommended.
+ *
+ * @param text - The input text containing the XML structure.
+ * @returns An object with key-value pairs extracted from the XML, or null if parsing fails.
+ */
+declare function parseKeyValueXml(text: string): Record<string, any> | null;
+/**
+ * Parses a JSON object from a given text. The function looks for a JSON block wrapped in triple backticks
+ * with `json` language identifier, and if not found, it searches for an object pattern within the text.
+ * It then attempts to parse the JSON string into a JavaScript object. If parsing is successful and the result
+ * is an object (but not an array), it returns the object; otherwise, it tries to parse an array if the result
+ * is an array, or returns null if parsing is unsuccessful or the result is neither an object nor an array.
+ *
+ * @param text - The input text from which to extract and parse the JSON object.
+ * @returns An object parsed from the JSON string if successful; otherwise, null or the result of parsing an array.
+ */
+declare function parseJSONObjectFromText(text: string): Record<string, any> | null;
+/**
+ * Normalizes a JSON-like string by correcting formatting issues:
+ * - Removes extra spaces after '{' and before '}'.
+ * - Wraps unquoted values in double quotes.
+ * - Converts single-quoted values to double-quoted.
+ * - Ensures consistency in key-value formatting.
+ * - Normalizes mixed adjacent quote pairs.
+ *
+ * This is useful for cleaning up improperly formatted JSON strings
+ * before parsing them into valid JSON.
+ *
+ * @param str - The JSON-like string to normalize.
+ * @returns A properly formatted JSON string.
+ */
+declare const normalizeJsonString: (str: string) => string;
+/**
+ * Truncate text to fit within the character limit, ensuring it ends at a complete sentence.
+ */
+declare function truncateToCompleteSentence(text: string, maxLength: number): string;
+declare function splitChunks(content: string, chunkSize?: number, bleed?: number): Promise<string[]>;
+/**
+ * Trims the provided text prompt to a specified token limit using a tokenizer model and type.
+ */
+declare function trimTokens(prompt: string, maxTokens: number, runtime: IAgentRuntime): Promise<string>;
+declare function safeReplacer(): (key: string, value: any) => any;
+/**
+ * Parses a string to determine its boolean equivalent.
+ *
+ * Recognized affirmative values: "YES", "Y", "TRUE", "T", "1", "ON", "ENABLE"
+ * Recognized negative values: "NO", "N", "FALSE", "F", "0", "OFF", "DISABLE"
+ *
+ * @param {string | undefined | null} value - The input text to parse
+ * @returns {boolean} - Returns `true` for affirmative inputs, `false` for negative or unrecognized inputs
+ */
+declare function parseBooleanFromText(value: string | undefined | null): boolean;
+/**
+ * Validates a UUID value.
+ *
+ * @param {unknown} value - The value to validate.
+ * @returns {UUID | null} Returns the validated UUID value or null if validation fails.
+ */
+declare function validateUuid(value: unknown): UUID | null;
+/**
+ * Converts a string or number to a UUID.
+ *
+ * @param {string | number} target - The string or number to convert to a UUID.
+ * @returns {UUID} The UUID generated from the input target.
+ * @throws {TypeError} Throws an error if the input target is not a string.
+ */
+declare function stringToUuid(target: string | number): UUID;
+declare const getContentTypeFromMimeType: (mimeType: string) => ContentType | undefined;
+
+declare const characterSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    username: z.ZodOptional<z.ZodString>;
+    system: z.ZodOptional<z.ZodString>;
+    templates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>]>>>;
+    bio: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    messageExamples: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+            thought: z.ZodOptional<z.ZodString>;
+            actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            source: z.ZodOptional<z.ZodString>;
+            target: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+            channelType: z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            text: z.ZodOptional<z.ZodString>;
+            thought: z.ZodOptional<z.ZodString>;
+            actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            source: z.ZodOptional<z.ZodString>;
+            target: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+            channelType: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            text: z.ZodOptional<z.ZodString>;
+            thought: z.ZodOptional<z.ZodString>;
+            actions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            source: z.ZodOptional<z.ZodString>;
+            target: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            inReplyTo: z.ZodOptional<z.ZodString>;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+            channelType: z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        content?: {
+            thought?: string;
+            text?: string;
+            actions?: string[];
+            providers?: string[];
+            source?: string;
+            target?: string;
+            url?: string;
+            inReplyTo?: string;
+            attachments?: any[];
+            channelType?: string;
+        } & {
+            [k: string]: unknown;
+        };
+    }, {
+        name?: string;
+        content?: {
+            thought?: string;
+            text?: string;
+            actions?: string[];
+            providers?: string[];
+            source?: string;
+            target?: string;
+            url?: string;
+            inReplyTo?: string;
+            attachments?: any[];
+            channelType?: string;
+        } & {
+            [k: string]: unknown;
+        };
+    }>, "many">, "many">>;
+    postExamples: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    topics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    adjectives: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    knowledge: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        shared: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        shared?: boolean;
+        path?: string;
+    }, {
+        shared?: boolean;
+        path?: string;
+    }>, z.ZodObject<{
+        directory: z.ZodString;
+        shared: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        shared?: boolean;
+        directory?: string;
+    }, {
+        shared?: boolean;
+        directory?: string;
+    }>]>, "many">>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodNumber, z.ZodAny]>>>;
+    secrets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+    style: z.ZodOptional<z.ZodObject<{
+        all: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        chat: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        post: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        all?: string[];
+        chat?: string[];
+        post?: string[];
+    }, {
+        all?: string[];
+        chat?: string[];
+        post?: string[];
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    knowledge?: (string | {
+        shared?: boolean;
+        directory?: string;
+    } | {
+        shared?: boolean;
+        path?: string;
+    })[];
+    username?: string;
+    name?: string;
+    id?: string;
+    system?: string;
+    templates?: Record<string, string | ((...args: unknown[]) => unknown)>;
+    bio?: string | string[];
+    messageExamples?: {
+        name?: string;
+        content?: {
+            thought?: string;
+            text?: string;
+            actions?: string[];
+            providers?: string[];
+            source?: string;
+            target?: string;
+            url?: string;
+            inReplyTo?: string;
+            attachments?: any[];
+            channelType?: string;
+        } & {
+            [k: string]: unknown;
+        };
+    }[][];
+    postExamples?: string[];
+    topics?: string[];
+    adjectives?: string[];
+    plugins?: string[];
+    settings?: Record<string, any>;
+    secrets?: Record<string, string | number | boolean>;
+    style?: {
+        all?: string[];
+        chat?: string[];
+        post?: string[];
+    };
+}, {
+    knowledge?: (string | {
+        shared?: boolean;
+        directory?: string;
+    } | {
+        shared?: boolean;
+        path?: string;
+    })[];
+    username?: string;
+    name?: string;
+    id?: string;
+    system?: string;
+    templates?: Record<string, string | ((...args: unknown[]) => unknown)>;
+    bio?: string | string[];
+    messageExamples?: {
+        name?: string;
+        content?: {
+            thought?: string;
+            text?: string;
+            actions?: string[];
+            providers?: string[];
+            source?: string;
+            target?: string;
+            url?: string;
+            inReplyTo?: string;
+            attachments?: any[];
+            channelType?: string;
+        } & {
+            [k: string]: unknown;
+        };
+    }[][];
+    postExamples?: string[];
+    topics?: string[];
+    adjectives?: string[];
+    plugins?: string[];
+    settings?: Record<string, any>;
+    secrets?: Record<string, string | number | boolean>;
+    style?: {
+        all?: string[];
+        chat?: string[];
+        post?: string[];
+    };
+}>;
+interface CharacterValidationResult {
+    success: boolean;
+    data?: Character;
+    error?: {
+        message: string;
+        issues?: z.ZodIssue[];
+    };
+}
+/**
+ * Safely validates character data using Zod schema
+ * @param data - Raw character data to validate
+ * @returns Validation result with success flag and either data or error
+ */
+declare function validateCharacter(data: unknown): CharacterValidationResult;
+/**
+ * Safely parses JSON string and validates as character
+ * @param jsonString - JSON string to parse and validate
+ * @returns Validation result with success flag and either data or error
+ */
+declare function parseAndValidateCharacter(jsonString: string): CharacterValidationResult;
+/**
+ * Type guard to check if data is a valid Character
+ * @param data - Data to check
+ * @returns True if data is a valid Character
+ */
+declare function isValidCharacter(data: unknown): data is Character;
+
 /**
  * Composes a set of example conversations based on provided actions and a specified count.
  * It randomly selects examples from the provided actions and formats them with generated names.
@@ -900,7 +1296,7 @@ declare let logger: pino.Logger<string, boolean>;
 declare const elizaLogger: pino.Logger<string, boolean>;
 
 declare const shouldRespondTemplate = "<task>Decide on behalf of {{agentName}} whether they should respond to the message, ignore it or stop the conversation.</task>\n\n<providers>\n{{providers}}\n</providers>\n\n<instructions>Decide if {{agentName}} should respond to or interact with the conversation.\nIf the message is directed at or relevant to {{agentName}}, respond with RESPOND action.\nIf a user asks {{agentName}} to be quiet, respond with STOP action.\nIf {{agentName}} should ignore the message, respond with IGNORE action.</instructions>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n  <name>{{agentName}}</name>\n  <reasoning>Your reasoning here</reasoning>\n  <action>RESPOND | IGNORE | STOP</action>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
-declare const messageHandlerTemplate = "<task>Generate dialog and actions for the character {{agentName}}.</task>\n\n<providers>\n{{providers}}\n</providers>\n\nThese are the available valid actions:\n<actionNames>\n{{actionNames}}\n</actionNames>\n\n<instructions>\nAnalyze the message and create a response plan for {{agentName}}.\n\nSTEP 1 - DETERMINE RESPONSE TYPE:\n- SIMPLE RESPONSE: If you only need to send a text reply without any tools, data lookups, or complex operations\n  \u2192 Use only REPLY action with no providers\n  \u2192 This is the preferred path for basic conversations\n  \u2192 Do NOT use this for questions that require checking stored knowledge!\n  \n- COMPLEX RESPONSE: If you need to:\n  \u2192 Use external tools or services (CALL_TOOL, etc.)\n  \u2192 Look up specific information (needs providers like KNOWLEDGE, ATTACHMENTS, etc.)\n  \u2192 Answer questions about what you know or might know (ALWAYS check KNOWLEDGE first!)\n  \u2192 Perform multiple operations\n  \u2192 Update data or settings\n\nSTEP 2 - PROVIDER SELECTION (for complex responses):\nIMPORTANT PROVIDER SELECTION RULES:\n- If the message mentions images, photos, pictures, attachments, or visual content, OR if you see \"(Attachments:\" in the conversation, you MUST include \"ATTACHMENTS\" in your providers list\n- If the message asks about or references specific people, include \"ENTITIES\" in your providers list  \n- If the message asks about relationships or connections between people, include \"RELATIONSHIPS\" in your providers list\n- If the message asks about facts or specific information, include \"FACTS\" in your providers list\n- If the message asks about the environment or world context, include \"WORLD\" in your providers list\n- **CRITICAL: If the message asks \"do you know\", \"who created\", \"what is\", \"tell me about\", or ANY question that might be answered by stored knowledge, you MUST include \"KNOWLEDGE\" in your providers list. Always check KNOWLEDGE before saying you don't know something!**\n- Some actions may require specific providers (this will be clear from the action's purpose)\n\nREMEMBER: It's better to check providers and find nothing than to assume you don't have information without checking!\n\nSTEP 3 - ACTION PLANNING:\nFor complex responses, consider the order of actions:\n- If using tools (CALL_TOOL, etc.): First REPLY to acknowledge the request (e.g., \"Let me check that for you\"), then execute the tool action\n- Tool actions often handle their own responses, so you may not need a final REPLY after them\n- Actions should flow logically: acknowledge \u2192 gather data \u2192 process \u2192 respond\n\nThink about your response as a plan:\n1. What is the user asking for?\n2. Do I need any additional context or data? (providers)\n3. What actions do I need to take and in what order?\n4. How will I communicate the results?\n</instructions>\n\n<output_format>\nFirst, think about what you want to do and create your plan.\n\nFor SIMPLE responses (text-only reply):\n- Set thought to explain your reasoning\n- Set actions to [\"REPLY\"]\n- Leave providers empty or set to []\n- Set text to your response message\n\nFor COMPLEX responses (using tools/providers):\n- Set thought to explain your plan and reasoning\n- Set actions in the order they should execute (e.g., [\"REPLY\", \"CALL_TOOL\"])\n- Set providers to gather needed context\n- Set text for your initial response (if using REPLY first)\n\nRemember: Some actions like CALL_TOOL will send their own responses, so plan accordingly.\n</output_format>\n\n<response>\n    <thought>User asking if I know something - must check KNOWLEDGE provider first before saying I don't know</thought>\n    <actions>REPLY</actions>\n    <providers>KNOWLEDGE</providers>\n    <text>Let me check if I have any information about Roxane's creator...</text>\n</response>\n</examples>\n\n<keys>\n\"thought\" should be a short description of what the agent is thinking about and their plan\n\"actions\" should be a comma-separated list of the actions {{agentName}} plans to take in order (if none, use IGNORE, if simply responding with text, use REPLY)\n\"providers\" should be a comma-separated list of the providers that {{agentName}} will use to have the right context for responding and acting (leave empty for simple responses)\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}} (used with REPLY action)\n</keys>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n    <thought>Your thought here</thought>\n    <actions>ACTION1,ACTION2</actions>\n    <providers>PROVIDER1,PROVIDER2</providers>\n    <text>Your response text here</text>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
+declare const messageHandlerTemplate = "<task>Generate dialog and actions for the character {{agentName}}.</task>\n\n<providers>\n{{providers}}\n</providers>\n\nThese are the available valid actions:\n<actionNames>\n{{actionNames}}\n</actionNames>\n\n<instructions>\nWrite a thought and plan for {{agentName}} and decide what actions to take. Also include the providers that {{agentName}} will use to have the right context for responding and acting, if any.\n\nIMPORTANT ACTION ORDERING RULES:\n- Actions are executed in the ORDER you list them - the order MATTERS!\n- REPLY should come FIRST to acknowledge the user's request before executing other actions\n- Common patterns:\n  - For requests requiring tool use: REPLY,CALL_MCP_TOOL (acknowledge first, then gather info)\n  - For task execution: REPLY,SEND_MESSAGE or REPLY,EVM_SWAP_TOKENS (acknowledge first, then do the task)\n  - For multi-step operations: REPLY,ACTION1,ACTION2 (acknowledge first, then complete all steps)\n- REPLY is used to acknowledge and inform the user about what you're going to do\n- Follow-up actions execute the actual tasks after acknowledgment\n- Use IGNORE only when you should not respond at all\n\nIMPORTANT PROVIDER SELECTION RULES:\n- If the message mentions images, photos, pictures, attachments, or visual content, OR if you see \"(Attachments:\" in the conversation, you MUST include \"ATTACHMENTS\" in your providers list\n- If the message asks about or references specific people, include \"ENTITIES\" in your providers list  \n- If the message asks about relationships or connections between people, include \"RELATIONSHIPS\" in your providers list\n- If the message asks about facts or specific information, include \"FACTS\" in your providers list\n- If the message asks about the environment or world context, include \"WORLD\" in your providers list\n- If you need external knowledge, information, or context beyond the current conversation to provide a helpful response, include \"KNOWLEDGE\" in your providers list\n\nFirst, think about what you want to do next and plan your actions. Then, write the next message and include the actions you plan to take.\n</instructions>\n\n<keys>\n\"thought\" should be a short description of what the agent is thinking about and planning.\n\"actions\" should be a comma-separated list of the actions {{agentName}} plans to take based on the thought, IN THE ORDER THEY SHOULD BE EXECUTED (if none, use IGNORE, if simply responding with text, use REPLY)\n\"providers\" should be a comma-separated list of the providers that {{agentName}} will use to have the right context for responding and acting (NEVER use \"IGNORE\" as a provider - use specific provider names like ATTACHMENTS, ENTITIES, FACTS, KNOWLEDGE, etc.)\n\"text\" should be the text of the next message for {{agentName}} which they will send to the conversation.\n</keys>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n    <thought>Your thought here</thought>\n    <actions>ACTION1,ACTION2</actions>\n    <providers>PROVIDER1,PROVIDER2</providers>\n    <text>Your response text here</text>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
 declare const postCreationTemplate = "# Task: Create a post in the voice and style and perspective of {{agentName}} @{{twitterUserName}}.\n\nExample task outputs:\n1. A post about the importance of AI in our lives\n<response>\n  <thought>I am thinking about writing a post about the importance of AI in our lives</thought>\n  <post>AI is changing the world and it is important to understand how it works</post>\n  <imagePrompt>A futuristic cityscape with flying cars and people using AI to do things</imagePrompt>\n</response>\n\n2. A post about dogs\n<response>\n  <thought>I am thinking about writing a post about dogs</thought>\n  <post>Dogs are man's best friend and they are loyal and loving</post>\n  <imagePrompt>A dog playing with a ball in a park</imagePrompt>\n</response>\n\n3. A post about finding a new job\n<response>\n  <thought>Getting a job is hard, I bet there's a good tweet in that</thought>\n  <post>Just keep going!</post>\n  <imagePrompt>A person looking at a computer screen with a job search website</imagePrompt>\n</response>\n\n{{providers}}\n\nWrite a post that is {{adjective}} about {{topic}} (without mentioning {{topic}} directly), from the perspective of {{agentName}}. Do not add commentary or acknowledge this request, just write the post.\nYour response should be 1, 2, or 3 sentences (choose the length at random).\nYour response should not contain any questions. Brief, concise statements only. The total character count MUST be less than 280. No emojis. Use \\n\\n (double spaces) between statements if there are multiple statements in your response.\n\nYour output should be formatted in XML like this:\n<response>\n  <thought>Your thought here</thought>\n  <post>Your post text here</post>\n  <imagePrompt>Optional image prompt here</imagePrompt>\n</response>\n\nThe \"post\" field should be the post you want to send. Do not including any thinking or internal reflection in the \"post\" field.\nThe \"imagePrompt\" field is optional and should be a prompt for an image that is relevant to the post. It should be a single sentence that captures the essence of the post. ONLY USE THIS FIELD if it makes sense that the post would benefit from an image.\nThe \"thought\" field should be a short description of what the agent is thinking about before responding, inlcuding a brief justification for the response. Includate an explanation how the post is relevant to the topic but unique and different than other posts.\n\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.";
 declare const booleanFooter = "Respond with only a YES or a NO.";
 declare const imageDescriptionTemplate = "<task>Analyze the provided image and generate a comprehensive description with multiple levels of detail.</task>\n\n<instructions>\nCarefully examine the image and provide:\n1. A concise, descriptive title that captures the main subject or scene\n2. A brief summary description (1-2 sentences) highlighting the key elements\n3. An extensive, detailed description that covers all visible elements, composition, lighting, colors, mood, and any other relevant details\n\nBe objective and descriptive. Focus on what you can actually see in the image rather than making assumptions about context or meaning.\n</instructions>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n  <title>A concise, descriptive title for the image</title>\n  <description>A brief 1-2 sentence summary of the key elements in the image</description>\n  <text>An extensive, detailed description covering all visible elements, composition, lighting, colors, mood, setting, objects, people, activities, and any other relevant details you can observe in the image</text>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
@@ -974,6 +1370,8 @@ declare class AgentRuntime implements IAgentRuntime {
     logger: any;
     private settings;
     private servicesInitQueue;
+    private currentRunId?;
+    private currentActionContext?;
     constructor(opts: {
         conversationLength?: number;
         agentId?: UUID;
@@ -987,6 +1385,22 @@ declare class AgentRuntime implements IAgentRuntime {
         };
         allAvailablePlugins?: Plugin[];
     });
+    /**
+     * Create a new run ID for tracking a sequence of model calls
+     */
+    createRunId(): UUID;
+    /**
+     * Start a new run for tracking prompts
+     */
+    startRun(): UUID;
+    /**
+     * End the current run
+     */
+    endRun(): void;
+    /**
+     * Get the current run ID (creates one if it doesn't exist)
+     */
+    getCurrentRunId(): UUID;
     registerPlugin(plugin: Plugin): Promise<void>;
     private resolvePluginDependencies;
     getAllServices(): Map<ServiceTypeName, Service>;
@@ -1090,6 +1504,7 @@ declare class AgentRuntime implements IAgentRuntime {
         start?: number;
         end?: number;
     }): Promise<Memory[]>;
+    getAllMemories(): Promise<Memory[]>;
     getMemoryById(id: UUID): Promise<Memory | null>;
     getMemoriesByIds(ids: UUID[], tableName?: string): Promise<Memory[]>;
     getMemoriesByRoomIds(params: {
@@ -1135,6 +1550,7 @@ declare class AgentRuntime implements IAgentRuntime {
     }): Promise<boolean>;
     deleteMemory(memoryId: UUID): Promise<void>;
     deleteManyMemories(memoryIds: UUID[]): Promise<void>;
+    clearAllAgentMemories(): Promise<void>;
     deleteAllMemories(roomId: UUID, tableName: string): Promise<void>;
     countMemories(roomId: UUID, unique?: boolean, tableName?: string): Promise<number>;
     getLogs(params: {
@@ -1302,174 +1718,6 @@ declare function encryptObjectValues(obj: Record<string, any>, salt: string): Re
  */
 declare function decryptObjectValues(obj: Record<string, any>, salt: string): Record<string, any>;
 
-/**
- * Composes a context string by replacing placeholders in a template with corresponding values from the state.
- *
- * This function takes a template string with placeholders in the format `{{placeholder}}` and a state object.
- * It replaces each placeholder with the value from the state object that matches the placeholder's name.
- * If a matching key is not found in the state object for a given placeholder, the placeholder is replaced with an empty string.
- *
- * @param {Object} params - The parameters for composing the context.
- * @param {State} params.state - The state object containing values to replace the placeholders in the template.
- * @param {TemplateType} params.template - The template string or function containing placeholders to be replaced with state values.
- * @returns {string} The composed context string with placeholders replaced by corresponding state values.
- *
- * @example
- * // Given a state object and a template
- * const state = { userName: "Alice", userAge: 30 };
- * const template = "Hello, {{userName}}! You are {{userAge}} years old";
- *
- * // Composing the context with simple string replacement will result in:
- * // "Hello, Alice! You are 30 years old."
- * const contextSimple = composePromptFromState({ state, template });
- *
- * // Using composePromptFromState with a template function for dynamic template
- * const template = ({ state }) => {
- * const tone = Math.random() > 0.5 ? "kind" : "rude";
- *   return `Hello, {{userName}}! You are {{userAge}} years old. Be ${tone}`;
- * };
- * const contextSimple = composePromptFromState({ state, template });
- */
-/**
- * Function to compose a prompt using a provided template and state.
- * It compiles the template (upgrading double braces to triple braces for non-HTML escaping)
- * and then populates it with values from the state. Additionally, it processes the
- * resulting string with `composeRandomUser` to replace placeholders like `{{nameX}}`.
- *
- * @param {Object} options - Object containing state and template information.
- * @param {State} options.state - The state object containing values to fill the template.
- * @param {TemplateType} options.template - The template string or function to be used for composing the prompt.
- * @returns {string} The composed prompt output, with state values and random user names populated.
- */
-declare const composePrompt: ({ state, template, }: {
-    state: {
-        [key: string]: string;
-    };
-    template: TemplateType;
-}) => string;
-/**
- * Function to compose a prompt using a provided template and state.
- *
- * @param {Object} options - Object containing state and template information.
- * @param {State} options.state - The state object containing values to fill the template.
- * @param {TemplateType} options.template - The template to be used for composing the prompt.
- * @returns {string} The composed prompt output.
- */
-declare const composePromptFromState: ({ state, template, }: {
-    state: State;
-    template: TemplateType;
-}) => string;
-/**
- * Adds a header to a body of text.
- *
- * This function takes a header string and a body string and returns a new string with the header prepended to the body.
- * If the body string is empty, the header is returned as is.
- *
- * @param {string} header - The header to add to the body.
- * @param {string} body - The body to which to add the header.
- * @returns {string} The body with the header prepended.
- *
- * @example
- * // Given a header and a body
- * const header = "Header";
- * const body = "Body";
- *
- * // Adding the header to the body will result in:
- * // "Header\nBody"
- * const text = addHeader(header, body);
- */
-declare const addHeader: (header: string, body: string) => string;
-declare const formatPosts: ({ messages, entities, conversationHeader, }: {
-    messages: Memory[];
-    entities: Entity[];
-    conversationHeader?: boolean;
-}) => string;
-/**
- * Format messages into a string
- * @param {Object} params - The formatting parameters
- * @param {Memory[]} params.messages - List of messages to format
- * @param {Entity[]} params.entities - List of entities for name resolution
- * @returns {string} Formatted message string with timestamps and user information
- */
-declare const formatMessages: ({ messages, entities, }: {
-    messages: Memory[];
-    entities: Entity[];
-}) => string;
-declare const formatTimestamp: (messageDate: number) => string;
-/**
- * Parses key-value pairs from a simple XML structure within a given text.
- * It looks for an XML block (e.g., <response>...</response>) and extracts
- * text content from direct child elements (e.g., <key>value</key>).
- *
- * Note: This uses regex and is suitable for simple, predictable XML structures.
- * For complex XML, a proper parsing library is recommended.
- *
- * @param text - The input text containing the XML structure.
- * @returns An object with key-value pairs extracted from the XML, or null if parsing fails.
- */
-declare function parseKeyValueXml(text: string): Record<string, any> | null;
-/**
- * Parses a JSON object from a given text. The function looks for a JSON block wrapped in triple backticks
- * with `json` language identifier, and if not found, it searches for an object pattern within the text.
- * It then attempts to parse the JSON string into a JavaScript object. If parsing is successful and the result
- * is an object (but not an array), it returns the object; otherwise, it tries to parse an array if the result
- * is an array, or returns null if parsing is unsuccessful or the result is neither an object nor an array.
- *
- * @param text - The input text from which to extract and parse the JSON object.
- * @returns An object parsed from the JSON string if successful; otherwise, null or the result of parsing an array.
- */
-declare function parseJSONObjectFromText(text: string): Record<string, any> | null;
-/**
- * Normalizes a JSON-like string by correcting formatting issues:
- * - Removes extra spaces after '{' and before '}'.
- * - Wraps unquoted values in double quotes.
- * - Converts single-quoted values to double-quoted.
- * - Ensures consistency in key-value formatting.
- * - Normalizes mixed adjacent quote pairs.
- *
- * This is useful for cleaning up improperly formatted JSON strings
- * before parsing them into valid JSON.
- *
- * @param str - The JSON-like string to normalize.
- * @returns A properly formatted JSON string.
- */
-declare const normalizeJsonString: (str: string) => string;
-/**
- * Truncate text to fit within the character limit, ensuring it ends at a complete sentence.
- */
-declare function truncateToCompleteSentence(text: string, maxLength: number): string;
-declare function splitChunks(content: string, chunkSize?: number, bleed?: number): Promise<string[]>;
-/**
- * Trims the provided text prompt to a specified token limit using a tokenizer model and type.
- */
-declare function trimTokens(prompt: string, maxTokens: number, runtime: IAgentRuntime): Promise<string>;
-declare function safeReplacer(): (key: string, value: any) => any;
-/**
- * Parses a string to determine its boolean equivalent.
- *
- * Recognized affirmative values: "YES", "Y", "TRUE", "T", "1", "ON", "ENABLE"
- * Recognized negative values: "NO", "N", "FALSE", "F", "0", "OFF", "DISABLE"
- *
- * @param {string | undefined | null} value - The input text to parse
- * @returns {boolean} - Returns `true` for affirmative inputs, `false` for negative or unrecognized inputs
- */
-declare function parseBooleanFromText(value: string | undefined | null): boolean;
-/**
- * Validates a UUID value.
- *
- * @param {unknown} value - The value to validate.
- * @returns {UUID | null} Returns the validated UUID value or null if validation fails.
- */
-declare function validateUuid(value: unknown): UUID | null;
-/**
- * Converts a string or number to a UUID.
- *
- * @param {string | number} target - The string or number to convert to a UUID.
- * @returns {UUID} The UUID generated from the input target.
- * @throws {TypeError} Throws an error if the input target is not a string.
- */
-declare function stringToUuid(target: string | number): UUID;
-
 declare const defaultSpec: typeof v2;
 
-export { Action, Agent, AgentRuntime, ChannelType, Character, Component, Content, DatabaseAdapter, type DeriveKeyAttestationData, Entity, Evaluator, HandlerCallback, IAgentRuntime, IDatabaseAdapter, ILpService, ITokenDataService, IWalletService, Log, type LpPositionDetails, Memory, MemoryMetadata, Metadata, ModelHandler, ModelParamsMap, ModelResultMap, ModelTypeName, OnboardingConfig, Participant, Plugin, type PoolInfo, Provider, Relationship, type RemoteAttestationMessage, type RemoteAttestationQuote, Role, Room, Route, RuntimeSettings, Semaphore, SendHandlerFunction, type ServerOwnershipState, Service, ServiceTypeName, Setting, State, TEEMode, TargetInfo, Task, TaskWorker, type TeeAgent, type TeePluginConfig, TeeType, TemplateType, type TokenBalance, type TokenData, type TransactionResult, UUID, type WalletAsset, type WalletPortfolio, World, WorldSettings, addHeader, booleanFooter, composeActionExamples, composePrompt, composePromptFromState, createLogger, createSettingFromConfig, createUniqueUuid, decryptObjectValues, decryptStringValue as decryptSecret, decryptStringValue, decryptedCharacter, defaultSpec, elizaLogger, encryptObjectValues, encryptStringValue, encryptedCharacter, findEntityByName, findWorldsForOwner, formatActionNames, formatActions, formatEntities, formatMessages, formatPosts, formatTimestamp, getEntityDetails, getSalt, getUserServerRole, getWorldSettings, imageDescriptionTemplate, initializeOnboarding, logger, messageHandlerTemplate, normalizeJsonString, parseBooleanFromText, parseJSONObjectFromText, parseKeyValueXml, postCreationTemplate, safeReplacer, saltSettingValue, saltWorldSettings, shouldRespondTemplate, splitChunks, stringToUuid, trimTokens, truncateToCompleteSentence, unsaltSettingValue, unsaltWorldSettings, updateWorldSettings, v2, validateUuid };
+export { Action, Agent, AgentRuntime, ChannelType, Character, type CharacterValidationResult, Component, Content, ContentType, DatabaseAdapter, type DeriveKeyAttestationData, Entity, Evaluator, HandlerCallback, IAgentRuntime, IDatabaseAdapter, ILpService, ITokenDataService, IWalletService, Log, type LpPositionDetails, Memory, MemoryMetadata, Metadata, ModelHandler, ModelParamsMap, ModelResultMap, ModelTypeName, OnboardingConfig, Participant, Plugin, type PoolInfo, Provider, Relationship, type RemoteAttestationMessage, type RemoteAttestationQuote, Role, Room, Route, RuntimeSettings, Semaphore, SendHandlerFunction, type ServerOwnershipState, Service, ServiceTypeName, Setting, State, TEEMode, TargetInfo, Task, TaskWorker, type TeeAgent, type TeePluginConfig, TeeType, TemplateType, type TokenBalance, type TokenData, type TransactionResult, UUID, type WalletAsset, type WalletPortfolio, World, WorldSettings, addHeader, booleanFooter, characterSchema, composeActionExamples, composePrompt, composePromptFromState, createLogger, createSettingFromConfig, createUniqueUuid, decryptObjectValues, decryptStringValue as decryptSecret, decryptStringValue, decryptedCharacter, defaultSpec, elizaLogger, encryptObjectValues, encryptStringValue, encryptedCharacter, findEntityByName, findWorldsForOwner, formatActionNames, formatActions, formatEntities, formatMessages, formatPosts, formatTimestamp, getContentTypeFromMimeType, getEntityDetails, getSalt, getUserServerRole, getWorldSettings, imageDescriptionTemplate, initializeOnboarding, isValidCharacter, logger, messageHandlerTemplate, normalizeJsonString, parseAndValidateCharacter, parseBooleanFromText, parseJSONObjectFromText, parseKeyValueXml, postCreationTemplate, safeReplacer, saltSettingValue, saltWorldSettings, shouldRespondTemplate, splitChunks, stringToUuid, trimTokens, truncateToCompleteSentence, unsaltSettingValue, unsaltWorldSettings, updateWorldSettings, v2, validateCharacter, validateUuid };