Build a Praxa backend with Rust

[dependencies]
reqwest = { version = "0.13", features = ["json", "rustls"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sha2 = "0.10"
thiserror = "2"
tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] }

use reqwest::{Client, StatusCode};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::time::Duration;
use thiserror::Error;

#[derive(Clone)]
pub struct Praxa {
    client: Client,
    api_key: String,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct ExecuteTaskRequest<'a> {
    api_version: &'static str,
    request_id: &'a str,
    mode: &'static str,
    task: Task<'a>,
    idempotency_key: &'a str,
}

#[derive(Debug, Serialize)]
struct Task<'a> {
    input: &'a str,
}

#[derive(Debug, Deserialize)]
pub struct Run {
    pub run_id: String,
    pub status: String,
}

#[derive(Debug, Error)]
pub enum PraxaError {
    #[error("invalid task")]
    InvalidTask,
    #[error("Praxa returned HTTP {0}")]
    Http(StatusCode),
    #[error(transparent)]
    Transport(#[from] reqwest::Error),
}

impl Praxa {
    pub fn new(api_key: String) -> Result<Self, reqwest::Error> {
        let client = Client::builder()
            .timeout(Duration::from_secs(30))
            .user_agent("your-service/1.0")
            .build()?;
        Ok(Self { client, api_key })
    }

    pub async fn submit_task(
        &self,
        user_id: &str,
        logical_request_id: &str,
        input: &str,
    ) -> Result<Run, PraxaError> {
        if input.is_empty() || input.chars().count() > 16_000 {
            return Err(PraxaError::InvalidTask);
        }

        let digest = Sha256::digest(format!("{user_id}\0{logical_request_id}"));
        let idempotency_key = format!("rust:{digest:x}");
        let body = ExecuteTaskRequest {
            api_version: "v1",
            request_id: &idempotency_key,
            mode: "task",
            task: Task { input },
            idempotency_key: &idempotency_key,
        };

        let response = self.client
            .post("https://api.praxa.io/v1/execute")
            .bearer_auth(&self.api_key)
            .header("idempotency-key", &idempotency_key)
            .json(&body)
            .send()
            .await?;

        if !response.status().is_success() {
            return Err(PraxaError::Http(response.status()));
        }

        Ok(response.json().await?)
    }
}