cURL to Rust reqwest Code GeneratorHigh-Performance

use reqwest::Client;
use serde::{Deserialize, Serialize};

// Strongly-typed Request payload generated from cURL body
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagItem {
    pub role: String,
    pub content: String,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RequestPayload {
    pub model: String,
    pub temperature: f64,
    pub max_tokens: i64,
    pub stream: bool,
    pub messages: Vec<MessagItem>,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Reusable reqwest client (thread-safe, internal Arc connection pool)
    let client = Client::new();

    // Construct type-safe request payload
    let payload = RequestPayload {
        model: "gpt-4o".to_string(),
        temperature: 0.7,
        max_tokens: 1024,
        stream: false,
        messages: vec![
            MessagItem {
                role: "system".to_string(),
                content: "You are an expert Rust systems programmer.".to_string(),
            },
            MessagItem {
                role: "user".to_string(),
                content: "Explain zero-cost abstractions in reqwest and tokio.".to_string(),
            }
        ],
    };

    // Build and dispatch HTTP request
    let response = client.post("https://api.openai.com/v1/chat/completions")
        .bearer_auth("sk-proj-1234567890abcdef")
        .json(&payload)
        .send()
        .await?;

    // Inspect HTTP status code
    let status = response.status();
    println!("Status Code: {}", status);

    // Parse dynamic JSON payload into generic serde_json::Value
    if status.is_success() {
        let json_body: serde_json::Value = response.json().await?;
        println!("JSON Response:\n{}", serde_json::to_string_pretty(&json_body)?);
    } else {
        let err_body = response.text().await?;
        eprintln!("API returned error {}: {}", status, err_body);
    }

    Ok(())
}