@agentforge/testing 0.16.61 → 0.16.63

package/dist/index.d.cts

@@ -0,0 +1,800 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { BaseMessage } from '@langchain/core/messages';
+import { ChatResult } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { z } from 'zod';
+import { Tool, ToolCategory, Logger } from '@agentforge/core';
+
+/**
+ * Configuration for MockLLM
+ */
+interface MockLLMConfig {
+    /**
+     * Predefined responses to return
+     */
+    responses?: string[];
+    /**
+     * Response generator function
+     */
+    responseGenerator?: (messages: BaseMessage[]) => string;
+    /**
+     * Delay in milliseconds before responding
+     */
+    delay?: number;
+    /**
+     * Whether to throw an error
+     */
+    shouldError?: boolean;
+    /**
+     * Error message to throw
+     */
+    errorMessage?: string;
+    /**
+     * Model name to report
+     */
+    modelName?: string;
+}
+/**
+ * Mock LLM for testing
+ *
+ * @example
+ * ```typescript
+ * const llm = createMockLLM({
+ *   responses: ['Hello!', 'How can I help?']
+ * });
+ *
+ * const result = await llm.invoke([new HumanMessage('Hi')]);
+ * console.log(result.content); // 'Hello!'
+ * ```
+ */
+declare class MockLLM extends BaseChatModel {
+    private responses;
+    private responseGenerator?;
+    private delay;
+    private shouldError;
+    private errorMessage;
+    private callCount;
+    _llmType(): string;
+    constructor(config?: MockLLMConfig);
+    _generate(messages: BaseMessage[], options?: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    /**
+     * Get the number of times the LLM has been called
+     */
+    getCallCount(): number;
+    /**
+     * Reset the call count
+     */
+    resetCallCount(): void;
+}
+/**
+ * Create a mock LLM for testing
+ */
+declare function createMockLLM(config?: MockLLMConfig): MockLLM;
+/**
+ * Create a mock LLM that echoes the last message
+ */
+declare function createEchoLLM(): MockLLM;
+/**
+ * Create a mock LLM that always errors
+ */
+declare function createErrorLLM(errorMessage?: string): MockLLM;
+
+declare const defaultMockToolSchema: z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>;
+type DefaultMockToolSchema = typeof defaultMockToolSchema;
+type MockToolSchema = z.ZodTypeAny;
+type MockToolInput<TSchema extends MockToolSchema> = z.infer<TSchema>;
+type MockToolInstance<TSchema extends MockToolSchema> = Tool<MockToolInput<TSchema>, string>;
+type MockToolConfigWithoutSchema = Omit<MockToolConfig<DefaultMockToolSchema>, 'schema'> & {
+    schema?: undefined;
+};
+type SchemaBackedMockToolConfig<TSchema extends MockToolSchema> = MockToolConfig<TSchema> & {
+    schema: TSchema;
+};
+/**
+ * Configuration for mock tool
+ */
+interface MockToolConfig<TSchema extends MockToolSchema = DefaultMockToolSchema> {
+    /**
+     * Tool name
+     */
+    name?: string;
+    /**
+     * Tool description
+     */
+    description?: string;
+    /**
+     * Tool category
+     */
+    category?: ToolCategory;
+    /**
+     * Input schema
+     */
+    schema?: TSchema;
+    /**
+     * Implementation function
+     */
+    implementation?: (input: MockToolInput<TSchema>) => Promise<string> | string;
+    /**
+     * Whether to throw an error
+     */
+    shouldError?: boolean;
+    /**
+     * Error message to throw
+     */
+    errorMessage?: string;
+    /**
+     * Delay in milliseconds before responding
+     */
+    delay?: number;
+}
+declare function createMockTool(): MockToolInstance<DefaultMockToolSchema>;
+declare function createMockTool(config: MockToolConfigWithoutSchema): MockToolInstance<DefaultMockToolSchema>;
+declare function createMockTool<TSchema extends MockToolSchema>(config: SchemaBackedMockToolConfig<TSchema>): MockToolInstance<TSchema>;
+/**
+ * Create a mock tool that echoes its input
+ */
+declare function createEchoTool(name?: string): MockToolInstance<z.ZodObject<{
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+}, {
+    message: string;
+}>>;
+/**
+ * Create a mock tool that always errors
+ */
+declare function createErrorTool(name?: string, errorMessage?: string): MockToolInstance<z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>>;
+/**
+ * Create a mock tool with delay
+ */
+declare function createDelayedTool(name?: string, delay?: number): MockToolInstance<z.ZodObject<{
+    input: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+}, {
+    input: string;
+}>>;
+/**
+ * Create a calculator mock tool
+ */
+declare function createCalculatorTool(): MockToolInstance<z.ZodObject<{
+    operation: z.ZodEnum<["add", "subtract", "multiply", "divide"]>;
+    a: z.ZodNumber;
+    b: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, {
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}>>;
+
+type StateBuilderFields = Record<string, unknown> & {
+    messages?: BaseMessage[];
+};
+type MessageState = {
+    messages: BaseMessage[];
+};
+type BuiltState<TState extends StateBuilderFields> = TState & Partial<MessageState>;
+interface TestToolCall<TArgs = unknown> {
+    name: string;
+    args: TArgs;
+}
+interface TestToolResult<TResult = string> {
+    name: string;
+    result: TResult;
+}
+interface ReActTestState<TArgs = unknown, TResult = string> {
+    messages: BaseMessage[];
+    thoughts: string[];
+    toolCalls: Array<TestToolCall<TArgs>>;
+    toolResults: Array<TestToolResult<TResult>>;
+    scratchpad: string[];
+    iterations: number;
+    maxIterations: number;
+}
+interface PlanningStep<TStatus extends string = string> {
+    step: string;
+    status: TStatus;
+}
+interface PlanningTestState<TResultMap extends Record<string, unknown> = Record<string, unknown>, TStatus extends string = string> extends StateBuilderFields {
+    messages: BaseMessage[];
+    plan: Array<PlanningStep<TStatus>>;
+    currentStep: number;
+    results: Partial<TResultMap>;
+}
+/**
+ * Builder for creating test states
+ */
+declare class StateBuilder<TState extends StateBuilderFields = StateBuilderFields> {
+    private state;
+    /**
+     * Set a field in the state
+     */
+    set<K extends keyof TState>(key: K, value: TState[K]): this;
+    /**
+     * Set multiple fields in the state
+     */
+    setMany(fields: Partial<TState>): this;
+    private ensureMessages;
+    /**
+     * Add a message to the messages array
+     */
+    addMessage(message: BaseMessage): this;
+    /**
+     * Add multiple messages
+     */
+    addMessages(messages: ReadonlyArray<BaseMessage>): this;
+    /**
+     * Add a human message
+     */
+    addHumanMessage(content: string): this;
+    /**
+     * Add an AI message
+     */
+    addAIMessage(content: string): this;
+    /**
+     * Add a system message
+     */
+    addSystemMessage(content: string): this;
+    /**
+     * Build the state
+     */
+    build(): BuiltState<TState>;
+    /**
+     * Reset the builder
+     */
+    reset(): this;
+}
+/**
+ * Create a state builder
+ */
+declare function createStateBuilder<TState extends StateBuilderFields = StateBuilderFields>(): StateBuilder<TState>;
+/**
+ * Create a simple conversation state
+ */
+declare function createConversationState(messages: ReadonlyArray<string>): MessageState;
+/**
+ * Create a ReAct agent state
+ */
+declare function createReActState<TArgs = unknown, TResult = string>(config?: Partial<ReActTestState<TArgs, TResult>>): ReActTestState<TArgs, TResult>;
+/**
+ * Create a planning agent state
+ */
+declare function createPlanningState<TResultMap extends Record<string, unknown> = Record<string, unknown>, TStatus extends string = string>(config?: Partial<PlanningTestState<TResultMap, TStatus>>): PlanningTestState<TResultMap, TStatus>;
+
+type ToolCall<TArgs = unknown> = {
+    name: string;
+    args: TArgs;
+};
+type MessageLike<TType extends string = string> = {
+    content: unknown;
+    _getType: () => TType;
+};
+type AssertedMessage<TType extends string = string> = BaseMessage | MessageLike<TType>;
+/**
+ * Assert that a value is a message of a specific type
+ */
+declare function assertIsMessage(value: unknown): asserts value is AssertedMessage;
+declare function assertIsMessage(value: unknown, type: 'human'): asserts value is AssertedMessage<'human'>;
+declare function assertIsMessage(value: unknown, type: 'ai'): asserts value is AssertedMessage<'ai'>;
+declare function assertIsMessage(value: unknown, type: 'system'): asserts value is AssertedMessage<'system'>;
+declare function assertIsMessage(value: unknown, type: 'tool'): asserts value is AssertedMessage<'tool'>;
+/**
+ * Assert that messages array contains a message with specific content
+ */
+declare function assertMessageContains(messages: BaseMessage[], content: string): void;
+/**
+ * Assert that the last message contains specific content
+ */
+declare function assertLastMessageContains(messages: BaseMessage[], content: string): void;
+/**
+ * Assert that state has required fields
+ */
+declare function assertStateHasFields<TState extends object>(state: TState, fields: ReadonlyArray<keyof TState & (string | number)>): void;
+/**
+ * Assert that a tool was called with specific arguments
+ */
+declare function assertToolCalled(toolCalls: ReadonlyArray<ToolCall>, toolName: string): void;
+declare function assertToolCalled<TArgs extends Record<string, unknown>>(toolCalls: ReadonlyArray<ToolCall<TArgs>>, toolName: string, args: Partial<TArgs>): void;
+/**
+ * Assert that execution completed within time limit
+ */
+declare function assertCompletesWithin(fn: () => Promise<unknown>, maxMs: number): Promise<void>;
+/**
+ * Assert that a function throws an error with specific message
+ */
+declare function assertThrowsWithMessage(fn: () => Promise<unknown>, message: string): Promise<void>;
+/**
+ * Assert that state matches a snapshot
+ */
+declare function assertStateSnapshot<TState extends object>(state: TState, snapshot: Partial<TState>): void;
+/**
+ * Assert that messages have alternating types (human, ai, human, ai, ...)
+ */
+declare function assertAlternatingMessages(messages: BaseMessage[]): void;
+/**
+ * Assert that an array is not empty
+ */
+declare function assertNotEmpty<T>(array: readonly T[]): void;
+/**
+ * Assert that a value is within a range
+ */
+declare function assertInRange(value: number, min: number, max: number): void;
+/**
+ * Assert that agent iterations are within limit
+ */
+declare function assertIterationsWithinLimit(iterations: number, maxIterations: number): void;
+/**
+ * Assert that a result contains expected keys
+ */
+declare function assertHasKeys<TObject extends object>(obj: TObject, keys: ReadonlyArray<keyof TObject & string>): void;
+
+/**
+ * Sample conversation: Simple greeting
+ */
+declare const simpleGreeting: BaseMessage[];
+/**
+ * Sample conversation: Multi-turn conversation
+ */
+declare const multiTurnConversation: BaseMessage[];
+/**
+ * Sample conversation: Tool usage
+ */
+declare const toolUsageConversation: BaseMessage[];
+/**
+ * Sample conversation: Error handling
+ */
+declare const errorHandlingConversation: BaseMessage[];
+/**
+ * Sample conversation: Complex reasoning
+ */
+declare const complexReasoningConversation: BaseMessage[];
+/**
+ * Sample conversation: Long context
+ */
+declare const longContextConversation: BaseMessage[];
+/**
+ * Create a custom conversation
+ */
+declare function createConversation(exchanges: Array<{
+    human: string;
+    ai: string;
+}>): BaseMessage[];
+/**
+ * Create a conversation with system message
+ */
+declare function createConversationWithSystem(systemPrompt: string, exchanges: Array<{
+    human: string;
+    ai: string;
+}>): BaseMessage[];
+/**
+ * Sample data for testing
+ */
+declare const sampleData: {
+    /**
+     * Sample user inputs
+     */
+    userInputs: string[];
+    /**
+     * Sample AI responses
+     */
+    aiResponses: string[];
+    /**
+     * Sample tool calls
+     */
+    toolCalls: ({
+        name: string;
+        args: {
+            operation: string;
+            a: number;
+            b: number;
+            query?: undefined;
+        };
+    } | {
+        name: string;
+        args: {
+            query: string;
+            operation?: undefined;
+            a?: undefined;
+            b?: undefined;
+        };
+    } | {
+        name: string;
+        args: {
+            operation?: undefined;
+            a?: undefined;
+            b?: undefined;
+            query?: undefined;
+        };
+    })[];
+    /**
+     * Sample tool results
+     */
+    toolResults: {
+        name: string;
+        result: string;
+    }[];
+};
+
+/**
+ * Sample calculator tool
+ */
+declare const calculatorTool: Tool<{
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, string>;
+/**
+ * Sample search tool
+ */
+declare const searchTool: Tool<{
+    query: string;
+    limit?: number | undefined;
+}, string>;
+/**
+ * Sample time tool
+ */
+declare const timeTool: Tool<{
+    _dummy?: string | undefined;
+}, string>;
+/**
+ * Sample weather tool
+ */
+declare const weatherTool: Tool<{
+    location: string;
+    units?: "celsius" | "fahrenheit" | undefined;
+}, string>;
+/**
+ * Sample file reader tool
+ */
+declare const fileReaderTool: Tool<{
+    path: string;
+}, string>;
+/**
+ * Sample database query tool
+ */
+declare const databaseQueryTool: Tool<{
+    query: string;
+}, string>;
+/**
+ * All sample tools
+ */
+declare const sampleTools: (Tool<{
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, string> | Tool<{
+    query: string;
+    limit?: number | undefined;
+}, string> | Tool<{
+    _dummy?: string | undefined;
+}, string> | Tool<{
+    location: string;
+    units?: "celsius" | "fahrenheit" | undefined;
+}, string> | Tool<{
+    path: string;
+}, string> | Tool<{
+    query: string;
+}, string>)[];
+/**
+ * Get tools by category
+ */
+declare function getToolsByCategory(category: ToolCategory): (Tool<{
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, string> | Tool<{
+    query: string;
+    limit?: number | undefined;
+}, string> | Tool<{
+    _dummy?: string | undefined;
+}, string> | Tool<{
+    location: string;
+    units?: "celsius" | "fahrenheit" | undefined;
+}, string> | Tool<{
+    path: string;
+}, string> | Tool<{
+    query: string;
+}, string>)[];
+/**
+ * Get tool by name
+ */
+declare function getToolByName(name: string): Tool<{
+    operation: "add" | "subtract" | "multiply" | "divide";
+    a: number;
+    b: number;
+}, string> | Tool<{
+    query: string;
+    limit?: number | undefined;
+}, string> | Tool<{
+    _dummy?: string | undefined;
+}, string> | Tool<{
+    location: string;
+    units?: "celsius" | "fahrenheit" | undefined;
+}, string> | Tool<{
+    path: string;
+}, string> | Tool<{
+    query: string;
+}, string> | undefined;
+
+/**
+ * Agent-like contract used by the test runner.
+ */
+interface AgentTestAgent<TInput = unknown, TState = unknown> {
+    invoke(input: TInput): TState | Promise<TState>;
+}
+/**
+ * Captured runner step. The current runner preserves an empty step list, but
+ * this contract gives future step capture a typed state boundary.
+ */
+interface AgentTestRunnerStep<TState = unknown> {
+    state: TState;
+    messages: BaseMessage[];
+    timestamp: number;
+}
+/**
+ * Configuration for agent test runner
+ */
+interface AgentTestConfig<TState = unknown> {
+    /**
+     * Maximum time to wait for agent response (ms)
+     */
+    timeout?: number;
+    /**
+     * Whether to capture intermediate steps
+     */
+    captureSteps?: boolean;
+    /**
+     * Whether to validate state after each step
+     */
+    validateState?: boolean;
+    /**
+     * Custom state validator
+     */
+    stateValidator?: (state: TState | undefined) => boolean | Promise<boolean>;
+}
+/**
+ * Result from agent test run
+ */
+interface AgentTestResult<TState = unknown, TStep = AgentTestRunnerStep<TState>> {
+    /**
+     * Final state after execution
+     */
+    finalState: TState | undefined;
+    /**
+     * Messages exchanged
+     */
+    messages: BaseMessage[];
+    /**
+     * Execution time in milliseconds
+     */
+    executionTime: number;
+    /**
+     * Intermediate steps (if captured)
+     */
+    steps?: TStep[];
+    /**
+     * Whether the test passed
+     */
+    passed: boolean;
+    /**
+     * Error if test failed
+     */
+    error?: Error;
+}
+/**
+ * Agent test runner for integration testing
+ *
+ * @example
+ * ```typescript
+ * const runner = new AgentTestRunner(agent, {
+ *   timeout: 5000,
+ *   captureSteps: true
+ * });
+ *
+ * const result = await runner.run({
+ *   messages: [new HumanMessage('Hello')]
+ * });
+ *
+ * expect(result.passed).toBe(true);
+ * expect(result.messages.length).toBeGreaterThan(1);
+ * ```
+ */
+declare class AgentTestRunner<TInput = unknown, TState = unknown, TStep = AgentTestRunnerStep<TState>> {
+    private agent;
+    private config;
+    constructor(agent: AgentTestAgent<TInput, TState>, config?: AgentTestConfig<TState>);
+    /**
+     * Run the agent with given input
+     */
+    run(input: TInput): Promise<AgentTestResult<TState, TStep>>;
+    /**
+     * Run multiple test cases
+     */
+    runMany(inputs: TInput[]): Promise<AgentTestResult<TState, TStep>[]>;
+}
+/**
+ * Create an agent test runner
+ */
+declare function createAgentTestRunner<TInput = unknown, TState = unknown, TStep = AgentTestRunnerStep<TState>>(agent: AgentTestAgent<TInput, TState>, config?: AgentTestConfig<TState>): AgentTestRunner<TInput, TState, TStep>;
+
+/**
+ * Configuration for conversation simulator
+ */
+interface ConversationSimulatorConfig {
+    /**
+     * Maximum number of turns
+     */
+    maxTurns?: number;
+    /**
+     * Delay between turns (ms)
+     */
+    turnDelay?: number;
+    /**
+     * Whether to log conversation
+     */
+    verbose?: boolean;
+    /**
+     * Structured logger used for verbose conversation output
+     */
+    logger?: Logger;
+    /**
+     * Stop condition
+     */
+    stopCondition?: (messages: BaseMessage[]) => boolean;
+}
+/**
+ * Result from conversation simulation
+ */
+interface ConversationResult {
+    /**
+     * All messages in the conversation
+     */
+    messages: BaseMessage[];
+    /**
+     * Number of turns
+     */
+    turns: number;
+    /**
+     * Total execution time (ms)
+     */
+    totalTime: number;
+    /**
+     * Whether conversation completed successfully
+     */
+    completed: boolean;
+    /**
+     * Reason for stopping
+     */
+    stopReason: 'max_turns' | 'stop_condition' | 'error';
+    /**
+     * Error if any
+     */
+    error?: Error;
+}
+interface ConversationSimulatorInput {
+    messages: BaseMessage[];
+}
+/**
+ * Conversation simulator for testing multi-turn interactions
+ *
+ * @example
+ * ```typescript
+ * const simulator = new ConversationSimulator(agent, {
+ *   maxTurns: 5,
+ *   verbose: true
+ * });
+ *
+ * const result = await simulator.simulate([
+ *   'Hello',
+ *   'What can you do?',
+ *   'Help me calculate 2 + 2'
+ * ]);
+ *
+ * expect(result.turns).toBe(3);
+ * expect(result.completed).toBe(true);
+ * ```
+ */
+declare class ConversationSimulator<TState = unknown> {
+    private agent;
+    private config;
+    constructor(agent: AgentTestAgent<ConversationSimulatorInput, TState>, config?: ConversationSimulatorConfig);
+    /**
+     * Simulate a conversation with predefined user inputs
+     */
+    simulate(userInputs: string[]): Promise<ConversationResult>;
+    /**
+     * Simulate a conversation with dynamic user input generation
+     */
+    simulateDynamic(inputGenerator: (messages: BaseMessage[]) => string | null, maxTurns?: number): Promise<ConversationResult>;
+    private logVerboseTurn;
+}
+/**
+ * Create a conversation simulator
+ */
+declare function createConversationSimulator<TState = unknown>(agent: AgentTestAgent<ConversationSimulatorInput, TState>, config?: ConversationSimulatorConfig): ConversationSimulator<TState>;
+
+type SnapshotObject = Record<string, unknown>;
+interface SnapshotDiff {
+    added: SnapshotObject;
+    removed: SnapshotObject;
+    changed: Record<string, {
+        from: unknown;
+        to: unknown;
+    }>;
+}
+interface MessageSnapshot {
+    type: string;
+    content: unknown;
+}
+declare const ROOT_SNAPSHOT_DIFF_KEY = "$root";
+/**
+ * Snapshot configuration
+ */
+interface SnapshotConfig {
+    /**
+     * Fields to include in snapshot
+     */
+    includeFields?: string[];
+    /**
+     * Fields to exclude from snapshot
+     */
+    excludeFields?: string[];
+    /**
+     * Whether to normalize timestamps
+     */
+    normalizeTimestamps?: boolean;
+    /**
+     * Whether to normalize IDs
+     */
+    normalizeIds?: boolean;
+    /**
+     * Custom normalizer function
+     */
+    normalizer?: (value: unknown) => unknown;
+}
+/**
+ * Create a snapshot of state
+ */
+declare function createSnapshot<TState = unknown>(state: TState, config?: SnapshotConfig): unknown;
+/**
+ * Assert that state matches snapshot
+ */
+declare function assertMatchesSnapshot<TState = unknown>(state: TState, config?: SnapshotConfig): void;
+/**
+ * Create a snapshot of messages
+ */
+declare function createMessageSnapshot(messages: BaseMessage[], config?: SnapshotConfig): MessageSnapshot[];
+/**
+ * Assert that messages match snapshot
+ */
+declare function assertMessagesMatchSnapshot(messages: BaseMessage[], config?: SnapshotConfig): void;
+/**
+ * Compare two states for equality
+ */
+declare function compareStates<TState1 = unknown, TState2 = unknown>(state1: TState1, state2: TState2, config?: SnapshotConfig): boolean;
+/**
+ * Create a diff between two states
+ */
+declare function createStateDiff<TState1 = unknown, TState2 = unknown>(state1: TState1, state2: TState2, config?: SnapshotConfig): SnapshotDiff;
+/**
+ * Assert that state has changed
+ */
+declare function assertStateChanged<TStateBefore = unknown, TStateAfter = unknown>(stateBefore: TStateBefore, stateAfter: TStateAfter, expectedChanges: string[], config?: SnapshotConfig): void;
+
+export { type AgentTestAgent, type AgentTestConfig, type AgentTestResult, AgentTestRunner, type AgentTestRunnerStep, type AssertedMessage, type ConversationResult, ConversationSimulator, type ConversationSimulatorConfig, type MessageSnapshot, MockLLM, type MockLLMConfig, type MockToolConfig, type PlanningStep, type PlanningTestState, ROOT_SNAPSHOT_DIFF_KEY, type ReActTestState, type SnapshotConfig, type SnapshotDiff, type SnapshotObject, StateBuilder, type TestToolCall, type TestToolResult, assertAlternatingMessages, assertCompletesWithin, assertHasKeys, assertInRange, assertIsMessage, assertIterationsWithinLimit, assertLastMessageContains, assertMatchesSnapshot, assertMessageContains, assertMessagesMatchSnapshot, assertNotEmpty, assertStateChanged, assertStateHasFields, assertStateSnapshot, assertThrowsWithMessage, assertToolCalled, calculatorTool, compareStates, complexReasoningConversation, createAgentTestRunner, createCalculatorTool, createConversation, createConversationSimulator, createConversationState, createConversationWithSystem, createDelayedTool, createEchoLLM, createEchoTool, createErrorLLM, createErrorTool, createMessageSnapshot, createMockLLM, createMockTool, createPlanningState, createReActState, createSnapshot, createStateBuilder, createStateDiff, databaseQueryTool, errorHandlingConversation, fileReaderTool, getToolByName, getToolsByCategory, longContextConversation, multiTurnConversation, sampleData, sampleTools, searchTool, simpleGreeting, timeTool, toolUsageConversation, weatherTool };