@elizaos/core 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/utils/streaming.d.ts

@@ -1,179 +0,0 @@
-/**
- * Streaming utilities for filtering and extracting streamable content.
- *
- * This module provides implementations of {@link IStreamExtractor}:
- * - PassthroughExtractor - Simple passthrough (no filtering)
- * - XmlTagExtractor - Extract content from a specific XML tag
- * - ResponseStreamExtractor - Action-aware XML (for DefaultMessageService)
- * - ActionStreamFilter - Content-type aware filter (for action handlers)
- *
- * For the interface definition, see types/streaming.ts.
- * Implementations can use these or create their own extractors.
- */
-import type { IStreamExtractor, IStreamingRetryState } from '../types/streaming';
-import type { StreamingContext } from '../streaming-context';
-import type { UUID } from '../types';
-export type { IStreamExtractor, IStreamingRetryState } from '../types/streaming';
-/** Error codes for streaming operations */
-export type StreamErrorCode = 'CHUNK_TOO_LARGE' | 'BUFFER_OVERFLOW' | 'PARSE_ERROR' | 'TIMEOUT' | 'ABORTED';
-/**
- * Standardized error class for streaming operations.
- * Provides structured error codes for easier handling.
- */
-export declare class StreamError extends Error {
-    readonly code: StreamErrorCode;
-    readonly details?: Record<string, unknown>;
-    constructor(code: StreamErrorCode, message: string, details?: Record<string, unknown>);
-    /** Check if an error is a StreamError */
-    static isStreamError(error: unknown): error is StreamError;
-}
-/**
- * Creates a streaming retry state from an extractor.
- * Use this to track streaming state for intelligent retry logic.
- *
- * @example
- * ```ts
- * const extractor = new ResponseStreamExtractor();
- * const retryState = createStreamingRetryState(extractor);
- *
- * // After streaming fails...
- * if (retryState.isComplete()) {
- *   // Text extraction finished - use streamedText, no retry needed
- *   return retryState.getStreamedText();
- * } else {
- *   // Text was cut - retry with continuation prompt
- *   retryState.reset();
- *   // ... retry with: "You started: '${streamedText}', continue..."
- * }
- * ```
- */
-export declare function createStreamingRetryState(extractor: IStreamExtractor): IStreamingRetryState & {
-    _appendText: (text: string) => void;
-};
-/**
- * Creates a complete streaming context with retry state management.
- * Use this to avoid duplicating streaming context creation logic.
- *
- * @param extractor - The stream extractor to use (e.g., ResponseStreamExtractor, XmlTagExtractor)
- * @param onStreamChunk - Callback to send chunks to the client
- * @param messageId - Optional message ID for the streaming context
- * @returns A complete StreamingContext with retry state methods
- *
- * @example
- * ```ts
- * const ctx = createStreamingContext(
- *   new ResponseStreamExtractor(),
- *   async (chunk) => res.write(chunk),
- *   responseId
- * );
- *
- * await runWithStreamingContext(ctx, () => runtime.useModel(...));
- *
- * // After streaming, check retry state
- * if (ctx.isComplete()) {
- *   return ctx.getStreamedText();
- * }
- * ```
- */
-export declare function createStreamingContext(extractor: IStreamExtractor, onStreamChunk: (chunk: string, messageId?: UUID) => Promise<void>, messageId?: UUID): StreamingContext;
-/**
- * Streams all content as-is without any filtering.
- * Use when LLM output is already in the desired format (e.g., plain text responses).
- */
-export declare class PassthroughExtractor implements IStreamExtractor {
-    get done(): boolean;
-    push(chunk: string): string;
-    reset(): void;
-}
-/**
- * Extracts content from a specific XML tag, streaming it progressively.
- * Use when you have a simple XML format like `<response><text>content</text></response>`.
- *
- * @example
- * ```ts
- * const extractor = new XmlTagExtractor('text');
- * extractor.push('<response><text>Hello'); // Returns 'Hel' (keeps margin for split tags)
- * extractor.push(' world!</text></response>'); // Returns 'lo world!'
- * ```
- */
-export declare class XmlTagExtractor implements IStreamExtractor {
-    private readonly openTag;
-    private readonly closeTag;
-    private buffer;
-    private insideTag;
-    private finished;
-    constructor(tagName: string);
-    get done(): boolean;
-    push(chunk: string): string;
-    reset(): void;
-    /**
-     * Flush remaining buffered content when stream ends unexpectedly.
-     */
-    flush(): string;
-}
-/**
- * Extracts streamable text from XML-structured LLM responses with action-based routing.
- *
- * This is the default implementation used by DefaultMessageService.
- * It understands the `<actions>` tag to determine whether to stream `<text>` content.
- *
- * Strategy:
- * - Parse <actions> to determine if response is direct (REPLY) or delegated (other actions)
- * - If direct: stream <text> content immediately
- * - If delegated: skip <text> (action handler will generate its own response via ActionStreamFilter)
- *
- * For simpler use cases without action routing, use {@link XmlTagExtractor} instead.
- */
-export declare class ResponseStreamExtractor implements IStreamExtractor {
-    private static readonly STREAM_TAGS;
-    private buffer;
-    private insideTag;
-    private currentTag;
-    private finished;
-    private responseStrategy;
-    get done(): boolean;
-    reset(): void;
-    /**
-     * Flush remaining buffered content when stream ends unexpectedly.
-     * Returns content that was held back due to SAFE_MARGIN.
-     */
-    flush(): string;
-    push(chunk: string): string;
-    /** Detect response strategy from <actions> tag using indexOf (ReDoS-safe) */
-    private detectResponseStrategy;
-    /** Parse comma-separated actions */
-    private parseActions;
-    /** Check if actions represent a direct reply */
-    private isDirectReply;
-    /** Determine if a tag should be streamed based on strategy */
-    private shouldStreamTag;
-}
-/**
- * Filters action handler output for streaming.
- * Used by runtime.ts processActions() for each action's useModel calls.
- *
- * Auto-detects content type from first non-whitespace character:
- * - JSON (starts with { or [) → Don't stream (structured data for parsing)
- * - XML (starts with <) → Look for <text> tag and stream its content
- * - Plain text → Stream immediately
- */
-export declare class ActionStreamFilter implements IStreamExtractor {
-    private buffer;
-    private decided;
-    private contentType;
-    private insideTextTag;
-    private finished;
-    get done(): boolean;
-    reset(): void;
-    /**
-     * Flush remaining buffered content when stream ends unexpectedly.
-     */
-    flush(): string;
-    push(chunk: string): string;
-    /** Detect content type from first non-whitespace character */
-    private detectContentType;
-    /** Handle plain text - stream everything */
-    private handlePlainText;
-    /** Handle XML content - extract and stream <text> tag content */
-    private handleXml;
-}

package/dist/utils/streaming.d.ts.map

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

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

@@ -1,23 +0,0 @@
-/**
- * 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>
- *
- * Excludes: null, arrays, buffers, Date, RegExp, Map, Set, WeakMap, WeakSet, Error, Promise
- *
- * @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>;

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

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

package/dist/utils.d.ts

@@ -1,182 +0,0 @@
-import type { Entity, IAgentRuntime, Memory, State, TemplateType } from './types';
-import { UUID, ContentType } 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.
- * 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;
-export 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.
- *
- * @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 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, 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 | 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 declare function getLocalServerUrl(path: string): string;

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAW,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3F,OAAO,EAAa,IAAI,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA8BvD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,sBAG3B;IACD,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACjC,QAAQ,EAAE,YAAY,CAAC;CACxB,WAKA,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GAAI,sBAGpC;IACD,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;CACxB,WAiBA,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,EAAE,MAAM,MAAM,WAErD,CAAC;AAkCF,eAAO,MAAM,WAAW,GAAI,6CAIzB;IACD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,WAmDA,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,yBAG5B;IACD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,WA6DA,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,aAAa,MAAM,WAoBlD,CAAC;AAIF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAgOpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAuBpF;AAED;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,WAc9C,CAAC;AAEF;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CA0BlF;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,SAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAWjG;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,mBA0BzF;AAED,wBAAgB,YAAY,KAET,MAAM,MAAM,EAAE,OAAO,OAAO,aAS9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAmB9E;AAWD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAGxD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0B1D;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAUtE;AAsND,eAAO,MAAM,0BAA0B,GAAI,UAAU,MAAM,KAAG,WAAW,GAAG,SAQ3E,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGtD"}