Struct QueryResolver

pub struct QueryResolver<C: LowLevelClient> { /* private fields */ }

Query resolver that wraps a LowLevelClient and provides all generic methods. This allows for flexible composition - you can have arrays of dyn LowLevelClient and wrap them in QueryResolver as needed.

Implementations

impl<C: LowLevelClient> QueryResolver<C>

pub fn new(client: C, config: RetryConfig) -> Self

Examples found in repository

examples/readme_demo.rs (line 35)

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(())
}

examples/schema_demo.rs (line 51)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing
    tracing_subscriber::fmt::init();
    
    let client = MockVoid;
    let resolver = QueryResolver::new(client, RetryConfig::default());
    
    // Example 1: Analysis Result
    println!("=== Example 1: AnalysisResult Schema ===");
    let analysis_prompt = "Analyze this code for security vulnerabilities".to_string();
    
    // This would normally work with a real AI client, but MockVoid just returns "{}"
    // The important part is seeing how the schema gets generated and appended
    match resolver.query::<AnalysisResult>(analysis_prompt).await {
        Ok(result) => println!("Analysis result: {:?}", result),
        Err(e) => println!("Expected error with MockVoid: {}", e),
    }
    
    println!("\n=== Example 2: CodeReview Schema ===");
    let review_prompt = "Review this Rust function for code quality".to_string();
    
    match resolver.query::<CodeReview>(review_prompt).await {
        Ok(result) => println!("Review result: {:?}", result),
        Err(e) => println!("Expected error with MockVoid: {}", e),
    }
    
    // Demonstrate the schema generation directly
    println!("\n=== Generated Schema Examples ===");
    
    let analysis_schema_prompt = resolver.augment_prompt_with_schema::<AnalysisResult>(
        "Analyze this code".to_string()
    );
    println!("AnalysisResult schema-augmented prompt:");
    println!("{}", analysis_schema_prompt);
    
    println!("\n{}", "=".repeat(80));
    
    let review_schema_prompt = resolver.augment_prompt_with_schema::<CodeReview>(
        "Review this code".to_string()
    );
    println!("CodeReview schema-augmented prompt:");
    println!("{}", review_schema_prompt);
    
    Ok(())
}

examples/rich_schema_demo.rs (line 200)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Rich Schema Documentation Demo");
    println!("This shows how to use doc comments and schemars attributes for rich AI prompts\n");

    let client = MockVoid;
    let _resolver = QueryResolver::new(client.clone(), RetryConfig::default());
    
    // Generate and display the enhanced schema
    println!("=== Enhanced Analysis Result Schema ===");
    let schema = schema_for!(EnhancedAnalysisResult);
    let schema_json = serde_json::to_string_pretty(&schema)?;
    println!("{}\n", schema_json);
    
    println!("=== Detailed Code Review Schema ===");
    let review_schema = schema_for!(DetailedCodeReview);
    let review_schema_json = serde_json::to_string_pretty(&review_schema)?;
    println!("{}\n", review_schema_json);
    
    // Demonstrate how the prompt becomes structure-agnostic
    println!("=== Structure-Agnostic Prompt Example ===");
    let simple_prompt = "Analyze this code for security issues".to_string();
    
    let augmented_prompt = _resolver.augment_prompt_with_schema::<EnhancedAnalysisResult>(simple_prompt.clone());
    println!("Original prompt: '{}'", simple_prompt);
    println!("Length after schema augmentation: {} characters", augmented_prompt.len());
    println!("Schema provides all structural details automatically!\n");
    
    // Show the benefits
    println!("=== Key Benefits ===");
    println!("✅ Rich semantic documentation embedded in struct definitions");
    println!("✅ Automatic validation rules (ranges, examples, descriptions)");
    println!("✅ Enum variants with clear semantic meaning");
    println!("✅ Structure-agnostic prompts (just say what you want)");
    println!("✅ Self-documenting code with schema generation");
    println!("✅ AI gets comprehensive field meanings automatically");
    
    Ok(())
}

examples/flexible_client_demo.rs (line 37)

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 client(&self) -> &C

Get a reference to the underlying client

pub fn config(&self) -> &RetryConfig

Get a reference to the retry configuration

pub fn with_config(self, config: RetryConfig) -> Self

Update the retry configuration

pub async fn query_raw<T>( &self, prompt: String, ) -> Result<T, QueryResolverError>

where T: DeserializeOwned + Send,

Query with retry logic and automatic JSON parsing

pub async fn query<T>(&self, prompt: String) -> Result<T, QueryResolverError>

where T: DeserializeOwned + JsonSchema + Send,

Query with automatic schema-aware prompt augmentation

Examples found in repository

examples/readme_demo.rs (lines 38-40)

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(())
}

examples/schema_demo.rs (line 59)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing
    tracing_subscriber::fmt::init();
    
    let client = MockVoid;
    let resolver = QueryResolver::new(client, RetryConfig::default());
    
    // Example 1: Analysis Result
    println!("=== Example 1: AnalysisResult Schema ===");
    let analysis_prompt = "Analyze this code for security vulnerabilities".to_string();
    
    // This would normally work with a real AI client, but MockVoid just returns "{}"
    // The important part is seeing how the schema gets generated and appended
    match resolver.query::<AnalysisResult>(analysis_prompt).await {
        Ok(result) => println!("Analysis result: {:?}", result),
        Err(e) => println!("Expected error with MockVoid: {}", e),
    }
    
    println!("\n=== Example 2: CodeReview Schema ===");
    let review_prompt = "Review this Rust function for code quality".to_string();
    
    match resolver.query::<CodeReview>(review_prompt).await {
        Ok(result) => println!("Review result: {:?}", result),
        Err(e) => println!("Expected error with MockVoid: {}", e),
    }
    
    // Demonstrate the schema generation directly
    println!("\n=== Generated Schema Examples ===");
    
    let analysis_schema_prompt = resolver.augment_prompt_with_schema::<AnalysisResult>(
        "Analyze this code".to_string()
    );
    println!("AnalysisResult schema-augmented prompt:");
    println!("{}", analysis_schema_prompt);
    
    println!("\n{}", "=".repeat(80));
    
    let review_schema_prompt = resolver.augment_prompt_with_schema::<CodeReview>(
        "Review this code".to_string()
    );
    println!("CodeReview schema-augmented prompt:");
    println!("{}", review_schema_prompt);
    
    Ok(())
}

examples/flexible_client_demo.rs (line 40)

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 augment_prompt_with_schema<T>(&self, prompt: String) -> String

where T: JsonSchema,

Generate a JSON schema for the return type and append it to the prompt

Examples found in repository

examples/schema_demo.rs (lines 75-77)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing
    tracing_subscriber::fmt::init();
    
    let client = MockVoid;
    let resolver = QueryResolver::new(client, RetryConfig::default());
    
    // Example 1: Analysis Result
    println!("=== Example 1: AnalysisResult Schema ===");
    let analysis_prompt = "Analyze this code for security vulnerabilities".to_string();
    
    // This would normally work with a real AI client, but MockVoid just returns "{}"
    // The important part is seeing how the schema gets generated and appended
    match resolver.query::<AnalysisResult>(analysis_prompt).await {
        Ok(result) => println!("Analysis result: {:?}", result),
        Err(e) => println!("Expected error with MockVoid: {}", e),
    }
    
    println!("\n=== Example 2: CodeReview Schema ===");
    let review_prompt = "Review this Rust function for code quality".to_string();
    
    match resolver.query::<CodeReview>(review_prompt).await {
        Ok(result) => println!("Review result: {:?}", result),
        Err(e) => println!("Expected error with MockVoid: {}", e),
    }
    
    // Demonstrate the schema generation directly
    println!("\n=== Generated Schema Examples ===");
    
    let analysis_schema_prompt = resolver.augment_prompt_with_schema::<AnalysisResult>(
        "Analyze this code".to_string()
    );
    println!("AnalysisResult schema-augmented prompt:");
    println!("{}", analysis_schema_prompt);
    
    println!("\n{}", "=".repeat(80));
    
    let review_schema_prompt = resolver.augment_prompt_with_schema::<CodeReview>(
        "Review this code".to_string()
    );
    println!("CodeReview schema-augmented prompt:");
    println!("{}", review_schema_prompt);
    
    Ok(())
}

examples/rich_schema_demo.rs (line 217)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Rich Schema Documentation Demo");
    println!("This shows how to use doc comments and schemars attributes for rich AI prompts\n");

    let client = MockVoid;
    let _resolver = QueryResolver::new(client.clone(), RetryConfig::default());
    
    // Generate and display the enhanced schema
    println!("=== Enhanced Analysis Result Schema ===");
    let schema = schema_for!(EnhancedAnalysisResult);
    let schema_json = serde_json::to_string_pretty(&schema)?;
    println!("{}\n", schema_json);
    
    println!("=== Detailed Code Review Schema ===");
    let review_schema = schema_for!(DetailedCodeReview);
    let review_schema_json = serde_json::to_string_pretty(&review_schema)?;
    println!("{}\n", review_schema_json);
    
    // Demonstrate how the prompt becomes structure-agnostic
    println!("=== Structure-Agnostic Prompt Example ===");
    let simple_prompt = "Analyze this code for security issues".to_string();
    
    let augmented_prompt = _resolver.augment_prompt_with_schema::<EnhancedAnalysisResult>(simple_prompt.clone());
    println!("Original prompt: '{}'", simple_prompt);
    println!("Length after schema augmentation: {} characters", augmented_prompt.len());
    println!("Schema provides all structural details automatically!\n");
    
    // Show the benefits
    println!("=== Key Benefits ===");
    println!("✅ Rich semantic documentation embedded in struct definitions");
    println!("✅ Automatic validation rules (ranges, examples, descriptions)");
    println!("✅ Enum variants with clear semantic meaning");
    println!("✅ Structure-agnostic prompts (just say what you want)");
    println!("✅ Self-documenting code with schema generation");
    println!("✅ AI gets comprehensive field meanings automatically");
    
    Ok(())
}

Trait Implementations

impl<C: Clone + LowLevelClient> Clone for QueryResolver<C>

fn clone(&self) -> QueryResolver<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.