@elizaos/core 2.0.0-alpha.52 → 2.0.0-alpha.53

package/dist/utils/time-format.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Time formatting utilities.
+ *
+ * Provides functions for human-readable time display.
+ *
+ * @module utils/time-format
+ */
+/**
+ * Format a timestamp as a relative time string.
+ *
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Human-readable relative time string
+ *
+ * @example
+ * ```ts
+ * formatRelativeTime(Date.now() - 30000) // => "just now"
+ * formatRelativeTime(Date.now() - 300000) // => "5m ago"
+ * formatRelativeTime(Date.now() - 7200000) // => "2h ago"
+ * formatRelativeTime(Date.now() - 86400000) // => "Yesterday"
+ * formatRelativeTime(Date.now() - 604800000) // => "Jan 15" (or similar)
+ * ```
+ */
+export declare function formatRelativeTime(timestamp: number): string;
+/**
+ * Format a timestamp as a verbose relative string.
+ */
+export declare function formatTimestamp(timestamp: number): string;
+//# sourceMappingURL=time-format.d.ts.map

package/dist/utils/time-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-format.d.ts","sourceRoot":"","sources":["../../src/utils/time-format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgDH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/utils/type-guards.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type guard utilities for runtime type checking
+ * These functions help TypeScript narrow types safely
+ */
+/**
+ * Check if a value is a plain object (not a special object type)
+ * Type guard that narrows the type to Record<string, unknown>
+ *
+ * A plain object is one created via {} or new Object(), not a built-in
+ * or custom class instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { name: 'test' };
+ * if (isPlainObject(data)) {
+ *   // TypeScript knows data is Record<string, unknown>
+ *   console.log(data.name);
+ * }
+ * ```
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/utils/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../src/utils/type-guards.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8BH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,OAAO,GACZ,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2BlC"}

package/dist/utils.d.ts

@@ -0,0 +1,182 @@
+import type { Entity, IAgentRuntime, Memory, State, TemplateType } from "./types";
+import { ContentType, type UUID } from "./types";
+import { getLocalServerUrl } from "./utils/node";
+import { formatTimestamp } from "./utils/time-format";
+/**
+ * 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.
+ */
+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;
+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;
+/**
+ * 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>).
+ *
+ * Uses regex - suitable for simple XML. For complex XML, use a proper parser.
+ *
+ * @typeParam T - The expected shape of the parsed result. Defaults to Record<string, unknown>.
+ * @param text - The input text containing the XML structure.
+ * @returns The parsed object cast to type T, or null if parsing fails.
+ *
+ * @example
+ * interface MyResponse { thought: string; message: string; }
+ * const result = parseKeyValueXml<MyResponse>(xmlText);
+ * // result is MyResponse | null
+ */
+export declare function parseKeyValueXml<T = Record<string, unknown>>(text: string): T | null;
+/**
+ * Parses a JSON object from text (code block or raw). Uses JSON5 so LLM output with
+ * trailing commas, unquoted keys, or single quotes still parses (why: strict JSON often fails on model output).
+ * Returns null on parse failure so one bad block doesn't crash the flow.
+ *
+ * @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.
+ * @throws Will throw an error if parsing fails and cannot extract a valid JSON object.
+ */
+export declare function parseJSONObjectFromText(text: string): Record<string, unknown> | 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.
+ */
+export declare const normalizeJsonString: (str: string) => string;
+/**
+ * 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 declare function safeReplacer(): (_key: string, value: unknown) => unknown;
+/**
+ * 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 | boolean | 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.
+ */
+export 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.
+ */
+export declare function stringToUuid(target: string | number): UUID;
+/**
+ * Pre-warm the SHA-1 cache with common values using WebCrypto
+ * Call this during initialization to improve performance
+ */
+export declare function prewarmUuidCache(values: string[]): Promise<void>;
+export declare const getContentTypeFromMimeType: (mimeType: string) => ContentType | undefined;
+export { formatTimestamp, getLocalServerUrl };
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/dist/validation/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validation Module
+ *
+ * Re-exports all validation utilities from submodules.
+ */
+export * from "./secrets";
+//# sourceMappingURL=index.d.ts.map

package/dist/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,WAAW,CAAC"}

package/dist/validation/keywords.d.ts

@@ -0,0 +1,26 @@
+import type { Memory } from "../types";
+/**
+ * Validates if any of the given keywords are present in the recent message history.
+ *
+ * This function checks the current message content and the last 5 messages in the provided
+ * list for the presence of any of the provided keywords. The check is case-insensitive.
+ *
+ * @param message The current message memory
+ * @param recentMessages List of recent memories
+ * @param keywords List of keywords to check for
+ * @returns true if any keyword matches, false otherwise
+ */
+export declare function validateActionKeywords(message: Memory, recentMessages: Memory[], keywords: string[]): boolean;
+/**
+ * Validates if any of the recent message history matches the given regex.
+ *
+ * This function checks the current message content and the last 5 messages in the provided
+ * list against the provided regex pattern.
+ *
+ * @param message The current message memory
+ * @param recentMessages List of recent memories
+ * @param regex The regular expression to check against
+ * @returns true if the regex matches any message content, false otherwise
+ */
+export declare function validateActionRegex(message: Memory, recentMessages: Memory[], regex: RegExp): boolean;
+//# sourceMappingURL=keywords.d.ts.map

package/dist/validation/keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../src/validation/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EAAE,EACxB,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAsCT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,EAAE,EACxB,KAAK,EAAE,MAAM,GACZ,OAAO,CA8BT"}

package/dist/validation/secrets.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Secret Validation Module
+ *
+ * Consolidated validation patterns for secrets across the entire codebase.
+ * All secret validation should use these patterns to ensure consistency.
+ *
+ * @module validation/secrets
+ */
+/**
+ * Validation pattern definition
+ */
+export interface SecretValidationPattern {
+    /** Regular expression to validate the secret format */
+    pattern: RegExp;
+    /** Human-readable description of the expected format */
+    description: string;
+    /** Minimum length requirement */
+    minLength?: number;
+    /** Maximum length requirement */
+    maxLength?: number;
+    /** Example of a valid format (redacted/fake) */
+    example?: string;
+}
+/**
+ * Consolidated validation patterns for all secret types.
+ * These patterns validate the format of secrets without making API calls.
+ */
+export declare const SECRET_VALIDATION_PATTERNS: Record<string, SecretValidationPattern>;
+/**
+ * Result of a secret validation
+ */
+export interface SecretValidationResult {
+    /** Whether the secret is valid */
+    isValid: boolean;
+    /** Error message if invalid */
+    error?: string;
+    /** Warning message (valid but with caveats) */
+    warning?: string;
+    /** Additional details */
+    details?: string;
+    /** Timestamp of validation */
+    validatedAt: number;
+}
+/**
+ * Validate a secret key/value pair.
+ *
+ * @param key - The secret key name
+ * @param value - The secret value to validate
+ * @returns Validation result
+ */
+export declare function validateSecretKey(key: string, value: string): SecretValidationResult;
+/**
+ * Validate multiple secrets at once.
+ *
+ * @param secrets - Record of key-value pairs to validate
+ * @returns Record of validation results
+ */
+export declare function validateSecrets(secrets: Record<string, string>): Record<string, SecretValidationResult>;
+/**
+ * Check if all required secrets are present and valid.
+ *
+ * @param secrets - Record of secrets to check
+ * @param requiredKeys - Array of required key names
+ * @returns Object with missing and invalid keys
+ */
+export declare function checkRequiredSecrets(secrets: Record<string, string>, requiredKeys: string[]): {
+    valid: boolean;
+    missing: string[];
+    invalid: string[];
+    results: Record<string, SecretValidationResult>;
+};
+/**
+ * Get the validation pattern for a secret key.
+ *
+ * @param key - The secret key name
+ * @returns The validation pattern, or undefined if none exists
+ */
+export declare function getValidationPattern(key: string): SecretValidationPattern | undefined;
+/**
+ * Check if a key has a specific validation pattern.
+ *
+ * @param key - The secret key name
+ * @returns true if a pattern exists for this key
+ */
+export declare function hasValidationPattern(key: string): boolean;
+/**
+ * Infer the validation pattern key from a secret key name.
+ * Useful for keys that might have slight variations.
+ *
+ * @param key - The secret key name
+ * @returns The inferred pattern key, or the original key
+ */
+export declare function inferValidationPatternKey(key: string): string;
+//# sourceMappingURL=secrets.d.ts.map

package/dist/validation/secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../../src/validation/secrets.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAC9C,MAAM,EACN,uBAAuB,CA2NvB,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,WAAW,EAAE,MAAM,CAAC;CACpB;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACX,sBAAsB,CA0CxB;AA+DD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAQxC;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,YAAY,EAAE,MAAM,EAAE,GACpB;IACF,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CAChD,CA2BA;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,GAAG,EAAE,MAAM,GACT,uBAAuB,GAAG,SAAS,CAErC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgD7D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/core",
-  "version": "2.0.0-alpha.52",
+  "version": "2.0.0-alpha.53",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -104,5 +104,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2cbf9d4f80a067cace80d200ec1268648bb45cf0"
+  "gitHead": "cb192f7b21c441e9463d1af2f890c145814baad2"
 }