import { Message, RunResult, MockModel, TestModel, FunctionModel } from '../types/agent';
export interface TestModelResponse {
    content: string;
    toolCalls?: Array<{
        name: string;
        arguments: Record<string, any>;
    }>;
}
export declare class TestModelClient {
    private model;
    private logger;
    private callCount;
    constructor(model: MockModel);
    chatCompletion(options: {
        model: string;
        messages: Array<{
            role: string;
            content: string;
        }>;
        maxTokens?: number;
        temperature?: number;
    }): Promise<{
        choices: Array<{
            message: {
                role: string;
                content: string;
            };
        }>;
        usage: {
            prompt_tokens: number;
            completion_tokens: number;
            total_tokens: number;
        };
    }>;
    private handleTestModel;
    private handleFunctionModel;
    private generateToolCallResponse;
    private generateSingleToolCallResponse;
    private estimateTokens;
    getCallCount(): number;
    reset(): void;
}
export declare function createTestModel(responses: string[], toolBehavior?: 'call_all' | 'call_first' | 'call_none'): TestModel;
export declare function createFunctionModel(handler: (messages: Message[]) => Promise<string> | string): FunctionModel;
export declare const CommonTestModels: {
    echo: FunctionModel;
    fixed: (response: string) => TestModel;
    cycle: (responses: string[]) => TestModel;
    toolCaller: TestModel;
    error: FunctionModel;
    json: (data: any) => FunctionModel;
    conditional: (conditions: Array<{
        condition: (messages: Message[]) => boolean;
        response: string;
    }>, defaultResponse?: string) => FunctionModel;
    conversational: () => FunctionModel;
};
export declare class AgentTestUtilities {
    private static logger;
    static createMockDeps<T>(overrides?: Partial<T>): T;
    static createMessageHistory(exchanges: Array<{
        user: string;
        assistant: string;
    }>): Message[];
    static assertToolCalled(result: RunResult<any>, toolName: string, expectedArgs?: Record<string, any>): void;
    static assertToolCallCount(result: RunResult<any>, expectedCount: number): void;
    static assertOutputType<T>(result: RunResult<T>, validator: (output: T) => boolean, message?: string): void;
    static createTestHarness<TDeps, TOutput>(agentFactory: (deps: TDeps) => any, defaultDeps: TDeps): {
        run(input: string, depsOverrides?: Partial<TDeps>, options?: any): Promise<RunResult<TOutput>>;
        runWithHistory(input: string, history: Message[], depsOverrides?: Partial<TDeps>): Promise<RunResult<TOutput>>;
        createDeps: (overrides?: Partial<TDeps>) => TDeps & Partial<TDeps>;
    };
}
declare global {
    namespace jest {
        interface Matchers<R> {
            toHaveCalledTool(toolName: string, args?: Record<string, any>): R;
            toHaveToolCallCount(count: number): R;
            toHaveValidOutput<T>(validator: (output: T) => boolean): R;
        }
    }
}
export declare const agentMatchers: {
    toHaveCalledTool(received: RunResult<any>, toolName: string, expectedArgs?: Record<string, any>): {
        message: () => string;
        pass: boolean;
    };
    toHaveToolCallCount(received: RunResult<any>, expectedCount: number): {
        message: () => string;
        pass: boolean;
    };
    toHaveValidOutput<T>(received: RunResult<T>, validator: (output: T) => boolean): {
        message: () => string;
        pass: boolean;
    };
};
export declare function setupAgentTesting(): void;
//# sourceMappingURL=test-models.d.ts.map