@elizaos/test-utils 1.2.2

package/dist/index.d.ts

@@ -0,0 +1,950 @@
+import * as _elizaos_core from '@elizaos/core';
+import { TextGenerationParams, TextEmbeddingParams, IAgentRuntime, Character, Plugin, Memory, Content, IDatabaseAdapter, UUID, State, ActionResult, Action, Provider, Evaluator, Media, Service, ServiceTypeName, ProviderResult } from '@elizaos/core';
+
+/**
+ * Realistic Test Model Provider - Provides configurable but realistic AI model responses
+ * Replaces hardcoded mock responses with intelligent, context-aware responses
+ */
+declare class TestModelProvider {
+    private responses;
+    private patterns;
+    private defaultResponse;
+    private contextHistory;
+    constructor(defaultResponse?: string, _options?: {
+        enableContextMemory?: boolean;
+        maxContextHistory?: number;
+    });
+    /**
+     * Add realistic default response patterns
+     */
+    private addDefaultPatterns;
+    /**
+     * Generate text response based on prompt
+     */
+    generateText(params: TextGenerationParams): Promise<string>;
+    /**
+     * Generate embeddings for text (mock implementation with consistent vectors)
+     */
+    generateEmbedding(params: TextEmbeddingParams): Promise<number[]>;
+    /**
+     * Generate object-structured responses
+     */
+    generateObject(params: any): Promise<Record<string, any>>;
+    /**
+     * Make response more contextual based on prompt content
+     */
+    private makeContextual;
+    /**
+     * Generate intelligent default response based on prompt analysis
+     */
+    private generateIntelligentDefault;
+    /**
+     * Extract key terms from prompt for contextualization
+     */
+    private extractKeyTerms;
+    /**
+     * Simple hash function for deterministic embeddings
+     */
+    private simpleHash;
+    /**
+     * Add interaction to context history
+     */
+    private addToHistory;
+    /**
+     * Set a specific response for a prompt
+     */
+    setResponse(prompt: string, response: string): void;
+    /**
+     * Add a pattern-based response
+     */
+    addPattern(pattern: RegExp, response: string): void;
+    /**
+     * Set the default response
+     */
+    setDefaultResponse(response: string): void;
+    /**
+     * Clear all custom responses and patterns
+     */
+    clear(): void;
+    /**
+     * Get conversation history
+     */
+    getHistory(): Array<{
+        prompt: string;
+        response: string;
+    }>;
+}
+/**
+ * Create a test model provider with specific scenarios
+ */
+declare function createTestModelProvider(scenarios?: Array<{
+    prompt: RegExp | string;
+    response: string;
+}>, defaultResponse?: string): TestModelProvider;
+/**
+ * Create specialized model provider for different types of testing
+ */
+declare function createSpecializedModelProvider(type: 'conversational' | 'analytical' | 'creative' | 'factual'): TestModelProvider;
+/**
+ * Model handler wrapper that integrates with ElizaOS runtime
+ */
+declare function createModelHandler(provider: TestModelProvider): (runtime: IAgentRuntime, params: any) => Promise<any>;
+/**
+ * Test scenario builder for common testing patterns
+ */
+declare class TestScenarioBuilder {
+    private scenarios;
+    addGreeting(response?: string): this;
+    addTaskCreation(response?: string): this;
+    addSearch(response?: string): this;
+    addCustom(prompt: RegExp | string, response: string): this;
+    build(defaultResponse?: string): TestModelProvider;
+}
+/**
+ * Convenience function to quickly create test scenarios
+ */
+declare function scenarios(): TestScenarioBuilder;
+
+interface RuntimeConfig {
+    character: Character;
+    plugins: Array<Plugin | string>;
+    databaseUrl?: string;
+    apiKeys: Record<string, string>;
+    modelProviders?: Record<string, any>;
+    isolated?: boolean;
+}
+interface RealRuntimeTestResult {
+    scenarioName: string;
+    passed: boolean;
+    errors: string[];
+    executedActions: string[];
+    createdMemories: number;
+    responseTime: number;
+    memoryUsage?: number;
+}
+/**
+ * Runtime Test Harness - Creates actual AgentRuntime instances for testing
+ * Uses the standard AgentRuntime without any mocks or proxies
+ */
+declare class RuntimeTestHarness {
+    private runtimes;
+    private databaseManager;
+    private testId;
+    constructor(testId?: string);
+    /**
+     * Creates an AgentRuntime instance for testing
+     * This uses the standard AgentRuntime - it will actually execute all functionality
+     */
+    createTestRuntime(config: RuntimeConfig): Promise<IAgentRuntime>;
+    /**
+     * Loads a plugin by name from the ElizaOS ecosystem
+     * Uses dynamic imports to avoid circular dependencies during build
+     */
+    private loadPlugin;
+    /**
+     * Creates a test model provider that gives realistic responses
+     */
+    createRealisticModelProvider(scenarios?: Array<{
+        prompt: RegExp;
+        response: string;
+    }>): TestModelProvider;
+    /**
+     * Executes a real message processing test
+     */
+    processTestMessage(runtime: IAgentRuntime, messageText: string, options?: {
+        roomId?: string;
+        entityId?: string;
+        expectedActions?: string[];
+        timeoutMs?: number;
+    }): Promise<RealRuntimeTestResult>;
+    /**
+     * Gets actions that were actually executed (not mocked)
+     */
+    private getExecutedActions;
+    /**
+     * Validates that a runtime is actually functional
+     */
+    validateRuntimeHealth(runtime: IAgentRuntime): Promise<{
+        healthy: boolean;
+        issues: string[];
+        services: string[];
+        plugins: string[];
+    }>;
+    /**
+     * Cleanup all test resources
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Convenience function to create and configure a test runtime
+ */
+declare function createTestRuntime(config?: Partial<RuntimeConfig>): Promise<{
+    runtime: IAgentRuntime;
+    harness: RuntimeTestHarness;
+}>;
+/**
+ * Helper to run a quick integration test
+ */
+declare function runIntegrationTest(testName: string, testFn: (runtime: IAgentRuntime) => Promise<void>, config?: Partial<RuntimeConfig>): Promise<RealRuntimeTestResult>;
+
+/**
+ * Standardized testing templates and patterns for ElizaOS
+ *
+ * This module provides consistent testing patterns, templates, and utilities
+ * to ensure testing consistency across all packages.
+ */
+
+/**
+ * Standard test configuration interface
+ */
+interface TestConfig {
+    name: string;
+    timeout?: number;
+    retries?: number;
+    skipCondition?: () => boolean;
+    setup?: () => Promise<void>;
+    teardown?: () => Promise<void>;
+    expectedErrors?: unknown[];
+}
+/**
+ * Template test result interface
+ */
+interface TemplateTestResult {
+    name: string;
+    passed: boolean;
+    duration: number;
+    error?: Error;
+    warnings?: string[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Base test template class
+ */
+declare abstract class TestTemplate {
+    protected config: TestConfig;
+    protected runtime?: IAgentRuntime;
+    constructor(config: TestConfig);
+    abstract execute(): Promise<TemplateTestResult>;
+    protected setup(): Promise<void>;
+    protected teardown(): Promise<void>;
+    protected shouldSkip(): boolean;
+    getConfig(): TestConfig;
+}
+/**
+ * Unit test template for isolated component testing
+ */
+declare class UnitTestTemplate extends TestTemplate {
+    private testFunction;
+    constructor(config: TestConfig, testFunction: () => Promise<void>);
+    execute(): Promise<TemplateTestResult>;
+}
+/**
+ * Integration test template for real runtime testing
+ */
+declare class IntegrationTestTemplate extends TestTemplate {
+    private testFunction;
+    private character?;
+    constructor(config: TestConfig, testFunction: (runtime: IAgentRuntime) => Promise<void>, character?: Character);
+    execute(): Promise<TemplateTestResult>;
+}
+/**
+ * Plugin test template for plugin-specific testing
+ */
+declare class PluginTestTemplate extends TestTemplate {
+    private plugin;
+    private testFunction;
+    constructor(config: TestConfig, plugin: Plugin, testFunction: (runtime: IAgentRuntime, plugin: Plugin) => Promise<void>);
+    execute(): Promise<TemplateTestResult>;
+}
+/**
+ * Error handling test template
+ */
+declare class ErrorTestTemplate extends TestTemplate {
+    private testFunction;
+    private expectedError;
+    constructor(config: TestConfig, testFunction: () => Promise<void>, expectedError: string);
+    execute(): Promise<TemplateTestResult>;
+}
+/**
+ * Performance test template
+ */
+declare class PerformanceTestTemplate extends TestTemplate {
+    private testFunction;
+    private maxDuration;
+    private maxMemoryMB;
+    constructor(config: TestConfig, testFunction: () => Promise<void>, maxDuration: number, maxMemoryMB: number);
+    execute(): Promise<TemplateTestResult>;
+}
+/**
+ * Test suite for organizing related tests
+ */
+declare class TestSuite {
+    private tests;
+    private name;
+    constructor(name: string);
+    addTest(test: TestTemplate): void;
+    run(): Promise<{
+        suiteName: string;
+        totalTests: number;
+        passed: number;
+        failed: number;
+        duration: number;
+        results: TemplateTestResult[];
+    }>;
+}
+/**
+ * Factory functions for creating common test scenarios
+ */
+declare function createUnitTest(name: string, testFunction: () => Promise<void>, options?: Partial<TestConfig>): UnitTestTemplate;
+declare function createIntegrationTest(name: string, testFunction: (runtime: IAgentRuntime) => Promise<void>, character?: Character, options?: Partial<TestConfig>): IntegrationTestTemplate;
+declare function createPluginTest(name: string, plugin: Plugin, testFunction: (runtime: IAgentRuntime, plugin: Plugin) => Promise<void>, options?: Partial<TestConfig>): PluginTestTemplate;
+declare function createErrorTest(name: string, testFunction: () => Promise<void>, expectedError: any, options?: Partial<TestConfig>): ErrorTestTemplate;
+declare function createPerformanceTest(name: string, testFunction: () => Promise<void>, maxDurationMs: number, maxMemoryMB: number, options?: Partial<TestConfig>): PerformanceTestTemplate;
+/**
+ * Standard test data generators
+ */
+declare class TestDataGenerator {
+    static generateUUID(): string;
+    static generateMemory(overrides?: Partial<Memory>): Memory;
+    static generateCharacter(overrides?: Partial<Character>): Character;
+    static generateContent(overrides?: Partial<Content>): Content;
+}
+
+/**
+ * Test Database Manager - Creates isolated database instances for testing
+ * Each test gets its own database to prevent interference and ensure isolation
+ */
+declare class TestDatabaseManager {
+    private testDatabases;
+    private tempPaths;
+    /**
+     * Creates an isolated database for testing
+     * Uses PostgreSQL for testing when available, falls back to mock database
+     */
+    createIsolatedDatabase(testId: string): Promise<IDatabaseAdapter>;
+    /**
+     * Creates a minimal mock database adapter for testing when real database unavailable
+     * This is a FUNCTIONAL mock that actually stores data in memory
+     */
+    private createMockDatabase;
+    /**
+     * Cleanup a specific test database
+     */
+    cleanupDatabase(testId: string): Promise<void>;
+    /**
+     * Cleanup all test databases
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get statistics about test databases
+     */
+    getStats(): {
+        activeDatabases: number;
+        tempPaths: string[];
+        memoryUsage: string;
+    };
+}
+/**
+ * Convenience function to create an isolated test database
+ */
+declare function createTestDatabase(testId?: string): Promise<{
+    adapter: IDatabaseAdapter;
+    manager: TestDatabaseManager;
+    testId: string;
+}>;
+
+/**
+ * Create a complete test environment with runtime, character, and conversation
+ *
+ * @param options - Configuration options for the test environment
+ * @returns Complete test environment
+ *
+ * @example
+ * ```typescript
+ * import { createTestEnvironment } from '@elizaos/core/test-utils';
+ *
+ * const { runtime, character, conversation } = createTestEnvironment({
+ *   characterName: 'TestBot',
+ *   conversationLength: 5,
+ *   roomId: 'test-room-123'
+ * });
+ * ```
+ */
+declare function createTestEnvironment(options?: {
+    characterName?: string;
+    conversationLength?: number;
+    roomId?: UUID;
+    plugins?: string[];
+    runtimeOverrides?: any;
+    characterOverrides?: any;
+}): {
+    runtime: IAgentRuntime;
+    character: _elizaos_core.Character;
+    conversation: Memory[];
+    state: State;
+    roomId: `${string}-${string}-${string}-${string}-${string}`;
+};
+/**
+ * Create a test action with complete mock setup
+ *
+ * @param name - Action name
+ * @param options - Action configuration options
+ * @returns Mock action with handlers
+ */
+declare function createTestAction(name: string, options?: {
+    description?: string;
+    validateResult?: boolean;
+    handlerResult?: ActionResult;
+    examples?: any[];
+}): Action;
+/**
+ * Create a test provider with complete mock setup
+ *
+ * @param name - Provider name
+ * @param options - Provider configuration options
+ * @returns Mock provider
+ */
+declare function createTestProvider(name: string, options?: {
+    description?: string;
+    text?: string;
+    values?: Record<string, any>;
+    data?: Record<string, any>;
+    dynamic?: boolean;
+    isPrivate?: boolean;
+}): Provider;
+/**
+ * Create a test evaluator with complete mock setup
+ *
+ * @param name - Evaluator name
+ * @param options - Evaluator configuration options
+ * @returns Mock evaluator
+ */
+declare function createTestEvaluator(name: string, options?: {
+    description?: string;
+    alwaysRun?: boolean;
+    validateResult?: boolean;
+    handlerResult?: any;
+}): Evaluator;
+/**
+ * Create a complete plugin test scenario
+ *
+ * @param pluginName - Name of the plugin being tested
+ * @param options - Plugin test configuration
+ * @returns Complete plugin test scenario
+ */
+declare function createPluginTestScenario(pluginName: string, options?: {
+    actions?: string[];
+    providers?: string[];
+    evaluators?: string[];
+    services?: string[];
+    conversationSteps?: string[];
+}): {
+    runtime: IAgentRuntime;
+    character: _elizaos_core.Character;
+    state: State;
+    roomId: `${string}-${string}-${string}-${string}-${string}`;
+    conversation: Memory[];
+    components: {
+        actions: Action[];
+        providers: Provider[];
+        evaluators: Evaluator[];
+    };
+    helpers: {
+        executeAction: (actionName: string, message?: Memory) => Promise<void | ActionResult>;
+        getProviderData: (providerName: string, message?: Memory) => Promise<_elizaos_core.ProviderResult>;
+        runEvaluator: (evaluatorName: string, message?: Memory) => Promise<void | ActionResult>;
+    };
+};
+/**
+ * Create a multi-agent test scenario
+ *
+ * @param agentCount - Number of agents to create
+ * @param options - Multi-agent test configuration
+ * @returns Multi-agent test scenario
+ */
+declare function createMultiAgentScenario(agentCount?: number, options?: {
+    sharedRoomId?: UUID;
+    agentNames?: string[];
+    conversationSteps?: Array<{
+        agentIndex: number;
+        message: string;
+    }>;
+}): {
+    agents: {
+        runtime: IAgentRuntime;
+        character: _elizaos_core.Character;
+        index: number;
+    }[];
+    sharedRoomId: `${string}-${string}-${string}-${string}-${string}`;
+    conversation: Memory[];
+    helpers: {
+        sendMessage: (agentIndex: number, text: string) => Memory;
+        getAgentByName: (name: string) => {
+            runtime: IAgentRuntime;
+            character: _elizaos_core.Character;
+            index: number;
+        };
+    };
+};
+
+/**
+ * @fileoverview Mock implementations for Character and related interfaces
+ *
+ * This module provides comprehensive mock implementations for character objects,
+ * agent configurations, and personality definitions.
+ */
+
+/**
+ * Type representing overrides for Character mock creation
+ */
+type MockCharacterOverrides = Partial<Character>;
+/**
+ * Create a comprehensive mock Character with intelligent defaults
+ *
+ * This function provides a fully-featured character mock that includes
+ * realistic personality traits, message examples, and configuration.
+ *
+ * @param overrides - Partial object to override specific properties
+ * @returns Complete mock Character object
+ *
+ * @example
+ * ```typescript
+ * import { createMockCharacter } from '@elizaos/core/test-utils';
+ *
+ * const mockCharacter = createMockCharacter({
+ *   name: 'CustomAgent',
+ *   bio: ['A specialized test agent'],
+ *   plugins: ['@elizaos/plugin-test']
+ * });
+ * ```
+ */
+declare function createMockCharacter(overrides?: MockCharacterOverrides): Character;
+/**
+ * Create a minimal mock character with only required fields
+ *
+ * @param name - Character name
+ * @param overrides - Additional overrides
+ * @returns Minimal mock character
+ */
+declare function createMinimalMockCharacter(name?: string, overrides?: MockCharacterOverrides): Character;
+/**
+ * Create a mock character for specific plugin testing
+ *
+ * @param pluginName - Name of the plugin to test
+ * @param overrides - Additional overrides
+ * @returns Plugin-specific mock character
+ */
+declare function createPluginTestCharacter(pluginName: string, overrides?: MockCharacterOverrides): Character;
+/**
+ * Create a mock character with extensive conversation examples
+ *
+ * @param overrides - Additional overrides
+ * @returns Character with rich conversation examples
+ */
+declare function createRichConversationCharacter(overrides?: MockCharacterOverrides): Character;
+/**
+ * Create multiple mock characters for multi-agent testing
+ *
+ * @param count - Number of characters to create
+ * @param baseName - Base name for characters (will be numbered)
+ * @param overrides - Common overrides for all characters
+ * @returns Array of mock characters
+ */
+declare function createMultipleCharacters(count?: number, baseName?: string, overrides?: MockCharacterOverrides): Character[];
+
+/**
+ * @fileoverview Mock implementations for IDatabaseAdapter and related database interfaces
+ *
+ * This module provides comprehensive mock implementations for database operations,
+ * supporting both unit and integration testing scenarios.
+ */
+
+/**
+ * Type representing overrides for IDatabaseAdapter mock creation
+ */
+type MockDatabaseOverrides = Partial<IDatabaseAdapter>;
+/**
+ * Create a comprehensive mock of IDatabaseAdapter with intelligent defaults
+ *
+ * This function provides a fully-featured database adapter mock that implements
+ * all database operations with sensible defaults and proper return types.
+ *
+ * @param overrides - Partial object to override specific methods or properties
+ * @returns Complete mock implementation of IDatabaseAdapter
+ *
+ * @example
+ * ```typescript
+ * import { createMockDatabase } from '@elizaos/core/test-utils';
+ * import { mock } from 'bun:test';
+ *
+ * const mockDb = createMockDatabase({
+ *   getMemories: mock().mockResolvedValue([mockMemory]),
+ *   createMemory: mock().mockResolvedValue('memory-id')
+ * });
+ * ```
+ */
+declare function createMockDatabase(overrides?: MockDatabaseOverrides): IDatabaseAdapter;
+/**
+ * Create a simple mock database connection object
+ *
+ * @param overrides - Partial object to override specific methods
+ * @returns Mock database connection
+ */
+declare function createMockDbConnection(overrides?: any): any;
+
+/**
+ * @fileoverview Mock implementations for Memory and related interfaces
+ *
+ * This module provides comprehensive mock implementations for memory objects,
+ * content structures, and memory-related operations.
+ */
+
+/**
+ * Type representing overrides for Memory mock creation
+ */
+type MockMemoryOverrides = Partial<Memory>;
+/**
+ * Type representing overrides for Content mock creation
+ */
+type MockContentOverrides = Partial<Content>;
+/**
+ * Create a comprehensive mock Memory object with intelligent defaults
+ *
+ * This function provides a fully-featured memory mock that includes
+ * realistic content, metadata, and proper typing.
+ *
+ * @param overrides - Partial object to override specific properties
+ * @returns Complete mock Memory object
+ *
+ * @example
+ * ```typescript
+ * import { createMockMemory } from '@elizaos/core/test-utils';
+ *
+ * const mockMessage = createMockMemory({
+ *   content: { text: 'Hello, world!' },
+ *   entityId: 'user-123'
+ * });
+ * ```
+ */
+declare function createMockMemory(overrides?: MockMemoryOverrides): Memory;
+/**
+ * Create a mock Content object with intelligent defaults
+ *
+ * @param overrides - Partial object to override specific properties
+ * @returns Complete mock Content object
+ *
+ * @example
+ * ```typescript
+ * import { createMockContent } from '@elizaos/core/test-utils';
+ *
+ * const mockContent = createMockContent({
+ *   text: 'Custom message',
+ *   actions: ['SEND_MESSAGE']
+ * });
+ * ```
+ */
+declare function createMockContent(overrides?: MockContentOverrides): Content;
+/**
+ * Create a mock conversation memory (user message)
+ *
+ * @param text - The message text
+ * @param overrides - Additional overrides
+ * @returns Mock user message memory
+ */
+declare function createMockUserMessage(text: string, overrides?: MockMemoryOverrides): Memory;
+/**
+ * Create a mock agent response memory
+ *
+ * @param text - The response text
+ * @param thought - Optional internal thought
+ * @param actions - Optional actions executed
+ * @param overrides - Additional overrides
+ * @returns Mock agent response memory
+ */
+declare function createMockAgentResponse(text: string, thought?: string, actions?: string[], overrides?: MockMemoryOverrides): Memory;
+/**
+ * Create a mock fact memory for knowledge storage
+ *
+ * @param fact - The factual claim
+ * @param confidence - Confidence level (0-1)
+ * @param overrides - Additional overrides
+ * @returns Mock fact memory
+ */
+declare function createMockFact(fact: string, confidence?: number, overrides?: MockMemoryOverrides): Memory;
+/**
+ * Create a mock memory with embedding vector
+ *
+ * @param text - The text content
+ * @param dimension - Embedding dimension (default: 1536 for OpenAI)
+ * @param overrides - Additional overrides
+ * @returns Mock memory with embedding
+ */
+declare function createMockMemoryWithEmbedding(text: string, dimension?: number, overrides?: MockMemoryOverrides): Memory;
+/**
+ * Create a batch of mock conversation memories
+ *
+ * @param count - Number of memories to create
+ * @param roomId - Room ID for all memories
+ * @returns Array of mock conversation memories
+ */
+declare function createMockConversation(count?: number, roomId?: UUID): Memory[];
+/**
+ * Create a mock Media attachment
+ *
+ * @param type - Media type
+ * @param url - Media URL
+ * @param overrides - Additional overrides
+ * @returns Mock Media object
+ */
+declare function createMockMedia(type?: 'image' | 'video' | 'audio' | 'document', url?: string, overrides?: Partial<Media>): Media;
+
+/**
+ * Simple mock utility for test utils that doesn't depend on bun:test
+ */
+interface MockFunction<T = any> {
+    (...args: any[]): T;
+    mockReturnValue: (value: T) => MockFunction<T>;
+    mockResolvedValue: (value: T) => MockFunction<T>;
+    mockRejectedValue: (error: any) => MockFunction<T>;
+    mockImplementation: (fn: (...args: any[]) => T) => MockFunction<T>;
+    calls: any[][];
+    mock: {
+        calls: any[][];
+        results: any[];
+    };
+}
+declare function mock<T = any>(implementation?: (...args: any[]) => T): MockFunction<T>;
+
+/**
+ * @fileoverview Mock implementations for IAgentRuntime and related interfaces
+ *
+ * This module provides comprehensive mock implementations for the core runtime interfaces,
+ * designed to support both unit testing and integration testing scenarios.
+ */
+
+/**
+ * Type representing overrides for IAgentRuntime mock creation
+ */
+type MockRuntimeOverrides = Partial<IAgentRuntime & IDatabaseAdapter>;
+/**
+ * Create a comprehensive mock of IAgentRuntime with intelligent defaults
+ *
+ * This function provides a fully-featured mock that implements both IAgentRuntime
+ * and IDatabaseAdapter interfaces, ensuring compatibility with all test scenarios.
+ *
+ * @param overrides - Partial object to override specific methods or properties
+ * @returns Complete mock implementation of IAgentRuntime
+ *
+ * @deprecated Use real runtime testing instead: import { createTestRuntime } from '@elizaos/core/test-utils'
+ *
+ * @example Legacy Mock Testing (Deprecated)
+ * ```typescript
+ * import { createMockRuntime } from '@elizaos/core/test-utils';
+ *
+ * const mockRuntime = createMockRuntime({
+ *   getSetting: () => 'test-api-key',
+ *   useModel: () => Promise.resolve('mock response')
+ * });
+ * ```
+ */
+declare function createMockRuntime(overrides?: MockRuntimeOverrides): IAgentRuntime;
+
+/**
+ * @fileoverview Mock implementations for Service and related interfaces
+ *
+ * This module provides comprehensive mock implementations for services,
+ * supporting both unit and integration testing scenarios.
+ */
+
+/**
+ * Type representing overrides for Service mock creation
+ */
+type MockServiceOverrides = Partial<Service>;
+/**
+ * Create a comprehensive mock Service with intelligent defaults
+ *
+ * This function provides a fully-featured service mock that implements
+ * the Service interface with sensible defaults and proper lifecycle methods.
+ *
+ * @param serviceType - Type/category of the service
+ * @param overrides - Partial object to override specific methods or properties
+ * @returns Complete mock Service implementation
+ *
+ * @example
+ * ```typescript
+ * import { createMockService } from '@elizaos/core/test-utils';
+ * import { mock } from 'bun:test';
+ *
+ * const mockService = createMockService(ServiceType.UNKNOWN, {
+ *   someMethod: mock().mockResolvedValue('custom result')
+ * });
+ * ```
+ */
+declare function createMockService(serviceType?: ServiceTypeName, overrides?: MockServiceOverrides): Service;
+/**
+ * Create a mock database service
+ *
+ * @param overrides - Service-specific overrides
+ * @returns Mock database service
+ */
+declare function createMockDatabaseService(overrides?: MockServiceOverrides): Service;
+/**
+ * Create a mock cache service
+ *
+ * @param overrides - Service-specific overrides
+ * @returns Mock cache service
+ */
+declare function createMockCacheService(overrides?: MockServiceOverrides): Service;
+/**
+ * Create a mock HTTP service
+ *
+ * @param overrides - Service-specific overrides
+ * @returns Mock HTTP service
+ */
+declare function createMockHttpService(overrides?: MockServiceOverrides): Service;
+/**
+ * Create a mock blockchain service
+ *
+ * @param overrides - Service-specific overrides
+ * @returns Mock blockchain service
+ */
+declare function createMockBlockchainService(overrides?: MockServiceOverrides): Service;
+/**
+ * Create a mock AI model service
+ *
+ * @param overrides - Service-specific overrides
+ * @returns Mock AI model service
+ */
+declare function createMockModelService(overrides?: MockServiceOverrides): Service;
+/**
+ * Create a mock messaging service
+ *
+ * @param overrides - Service-specific overrides
+ * @returns Mock messaging service
+ */
+declare function createMockMessagingService(overrides?: MockServiceOverrides): Service;
+/**
+ * Create a service map with multiple mock services
+ *
+ * @param services - Array of service configurations
+ * @returns Map of service names to mock services
+ */
+declare function createMockServiceMap(services?: Array<{
+    name: string;
+    type?: ServiceTypeName;
+    overrides?: MockServiceOverrides;
+}>): Map<string, Service>;
+/**
+ * Create a mock service registry for runtime
+ *
+ * @param runtime - Mock runtime instance
+ * @param services - Services to register
+ * @returns Updated runtime with registered services
+ */
+declare function registerMockServices(runtime: any, services?: Array<{
+    name: string;
+    type?: ServiceTypeName;
+    overrides?: MockServiceOverrides;
+}>): any;
+
+/**
+ * @fileoverview Mock implementations for State and related interfaces
+ *
+ * This module provides comprehensive mock implementations for state objects,
+ * provider results, and state composition utilities.
+ */
+
+/**
+ * Type representing overrides for State mock creation
+ */
+type MockStateOverrides = Partial<State>;
+/**
+ * Type representing overrides for ProviderResult mock creation
+ */
+type MockProviderResultOverrides = Partial<ProviderResult>;
+/**
+ * Type representing overrides for ActionResult mock creation
+ */
+type MockActionResultOverrides = Partial<ActionResult>;
+/**
+ * Create a comprehensive mock State object with intelligent defaults
+ *
+ * This function provides a fully-featured state mock that includes
+ * realistic data structures and proper typing for agent context.
+ *
+ * @param overrides - Partial object to override specific properties
+ * @returns Complete mock State object
+ *
+ * @example
+ * ```typescript
+ * import { createMockState } from '@elizaos/core/test-utils';
+ *
+ * const mockState = createMockState({
+ *   values: { currentUser: 'john_doe' },
+ *   data: { conversationLength: 5 }
+ * });
+ * ```
+ */
+declare function createMockState(overrides?: MockStateOverrides): State;
+/**
+ * Create a mock ProviderResult object
+ *
+ * @param overrides - Partial object to override specific properties
+ * @returns Complete mock ProviderResult object
+ *
+ * @example
+ * ```typescript
+ * import { createMockProviderResult } from '@elizaos/core/test-utils';
+ *
+ * const providerResult = createMockProviderResult({
+ *   text: '[WEATHER] Current weather is sunny',
+ *   values: { temperature: 72, conditions: 'sunny' }
+ * });
+ * ```
+ */
+declare function createMockProviderResult(overrides?: MockProviderResultOverrides): ProviderResult;
+/**
+ * Create a mock ActionResult object
+ *
+ * @param overrides - Partial object to override specific properties
+ * @returns Complete mock ActionResult object
+ *
+ * @example
+ * ```typescript
+ * import { createMockActionResult } from '@elizaos/core/test-utils';
+ *
+ * const actionResult = createMockActionResult({
+ *   text: 'Action completed successfully',
+ *   values: { success: true, id: 'action-123' }
+ * });
+ * ```
+ */
+declare function createMockActionResult(overrides?: MockActionResultOverrides): ActionResult;
+/**
+ * Create a state with specific provider context
+ *
+ * @param providerName - Name of the provider
+ * @param providerData - Data from the provider
+ * @param overrides - Additional state overrides
+ * @returns State with provider context
+ */
+declare function createMockStateWithProvider(providerName: string, providerData: any, overrides?: MockStateOverrides): State;
+/**
+ * Create a state with action execution history
+ *
+ * @param actionResults - Array of action results
+ * @param overrides - Additional state overrides
+ * @returns State with action history
+ */
+declare function createMockStateWithActions(actionResults: ActionResult[], overrides?: MockStateOverrides): State;
+/**
+ * Create a state with realistic conversation context
+ *
+ * @param conversationHistory - Array of recent messages
+ * @param currentUser - Current user name
+ * @param overrides - Additional state overrides
+ * @returns State with conversation context
+ */
+declare function createMockConversationState(conversationHistory?: string[], currentUser?: string, overrides?: MockStateOverrides): State;
+
+export { ErrorTestTemplate, IntegrationTestTemplate, type MockActionResultOverrides, type MockCharacterOverrides, type MockContentOverrides, type MockDatabaseOverrides, type MockFunction, type MockMemoryOverrides, type MockProviderResultOverrides, type MockRuntimeOverrides, type MockServiceOverrides, type MockStateOverrides, PerformanceTestTemplate, PluginTestTemplate, type RealRuntimeTestResult, type RuntimeConfig, RuntimeTestHarness, type TemplateTestResult, type TestConfig, TestDataGenerator, TestDatabaseManager, TestModelProvider, TestScenarioBuilder, TestSuite, TestTemplate, UnitTestTemplate, createErrorTest, createIntegrationTest, createMinimalMockCharacter, createMockActionResult, createMockAgentResponse, createMockBlockchainService, createMockCacheService, createMockCharacter, createMockContent, createMockConversation, createMockConversationState, createMockDatabase, createMockDatabaseService, createMockDbConnection, createMockFact, createMockHttpService, createMockMedia, createMockMemory, createMockMemoryWithEmbedding, createMockMessagingService, createMockModelService, createMockProviderResult, createMockRuntime, createMockService, createMockServiceMap, createMockState, createMockStateWithActions, createMockStateWithProvider, createMockUserMessage, createModelHandler, createMultiAgentScenario, createMultipleCharacters, createPerformanceTest, createPluginTest, createPluginTestCharacter, createPluginTestScenario, createRichConversationCharacter, createSpecializedModelProvider, createTestAction, createTestDatabase, createTestEnvironment, createTestEvaluator, createTestModelProvider, createTestProvider, createTestRuntime, createUnitTest, mock, registerMockServices, runIntegrationTest, scenarios };