Struct FlexibleClient

pub struct FlexibleClient { /* private fields */ }

Flexible client that wraps any LowLevelClient and provides factory functions

Implementations

impl FlexibleClient

pub fn new_lazy(client_type: ClientType) -> Self

Create a new FlexibleClient with lazy initialization

pub fn new(client: Box<dyn LowLevelClient>) -> Self

Create a new FlexibleClient wrapping the given client

pub fn with_interceptor(&self, interceptor: Arc<dyn Interceptor>) -> Self

Create a new FlexibleClient with an interceptor

pub fn with_file_interceptor(&self, path: PathBuf) -> Self

Create a new FlexibleClient with an interceptor

pub fn claude(config: ClaudeConfig) -> Self

Create a FlexibleClient with a Claude client

Examples found in repository

examples/readme_demo.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create Claude client (reads ANTHROPIC_API_KEY from environment)
    let client = FlexibleClient::claude(ClaudeConfig::default());
    let resolver = QueryResolver::new(client, RetryConfig::default());
    
    // Get 10 science quiz questions
    let quiz: Quiz = resolver.query(
        "Create 10 high school science quiz questions with A, B, C, D answers".to_string()
    ).await?;
    
    // Administer the quiz
    administer_quiz(quiz.questions).await;
    Ok(())
}

pub fn deepseek(config: DeepSeekConfig) -> Self

Create a FlexibleClient with a DeepSeek client

pub fn mock() -> (Self, Arc<MockHandle>)

Create a FlexibleClient with a mock and return the handle for configuration

Examples found in repository

examples/flexible_client_demo.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 FlexibleClient Demo");
    println!("=================");
    
    // Create different client types easily
    println!("\n1. Creating different client types:");
    let (mock_client, _) = FlexibleClient::mock();
    
    println!("   ✅ Mock client: {:?}", mock_client);
    println!("   📝 Claude/DeepSeek clients can be created with FlexibleClient::claude() / ::deepseek()");
    
    // Clone clients easily
    println!("\n2. Cloning clients:");
    let cloned_mock = mock_client.clone();
    println!("   ✅ Cloned mock client: {:?}", cloned_mock);
    
    // Extract boxed clients for use with other systems
    println!("\n3. Extract boxed clients:");
    let _boxed_client = cloned_mock.clone_box();
    println!("   ✅ Extracted boxed client from FlexibleClient");
    
    // Use with QueryResolver
    println!("\n4. Using with QueryResolver:");
    let resolver = QueryResolver::new(mock_client, RetryConfig::default());
    
    // Try a simple query (will return empty {} from mock)
    match resolver.query::<SimpleResponse>("Hello world".to_string()).await {
        Ok(response) => println!("   ✅ Query succeeded: {:?}", response),
        Err(e) => println!("   ❌ Query failed (expected with mock): {}", e),
    }
    
    // Demonstrate factory functions
    println!("\n5. Factory functions for dynamic client creation:");
    let mock_client2 = FlexibleClient::mock();
    println!("   ✅ Created mock client: {:?}", mock_client2);
    println!("   📝 Can also create claude/deepseek clients when API keys are available");
    
    println!("\n🎉 FlexibleClient demo completed!");
    println!("    - Easy construction with FlexibleClient::mock(), ::claude(), ::deepseek()");
    println!("    - Seamless cloning with .clone()");
    println!("    - Extract boxed clients with .clone_inner() or .into_inner()");
    println!("    - Works directly with QueryResolver");
    
    Ok(())
}

pub fn new_mock_with_responses( responses: Vec<MockResponse>, ) -> (Self, Arc<MockHandle>)

Create a FlexibleClient mock with predefined responses

pub fn into_inner(self) -> Result<Box<dyn LowLevelClient>, AIError>

Convert into the inner boxed client (initializes if needed)

Trait Implementations

impl Clone for FlexibleClient

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FlexibleClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl LowLevelClient for FlexibleClient

fn ask_raw<'life0, 'async_trait>( &'life0 self, prompt: String, ) -> Pin<Box<dyn Future<Output = Result<String, AIError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The only method that implementations must provide

fn clone_box(&self) -> Box<dyn LowLevelClient>

Clone this client into a boxed trait object

fn ask_json<'life0, 'async_trait>( &'life0 self, prompt: String, ) -> Pin<Box<dyn Future<Output = Result<String, AIError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Simple JSON extraction from a prompt response (default implementation)