Task Management

api_v1_job_job_id_get()

Get current task status:

use legnext_rust_sdk::{
    apis::configuration::Configuration,
    apis::image_api,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut config = Configuration::new();
    config.base_path = "https://api.legnext.ai".to_string();

    let api_key = "your-api-key-here";
    let job_id = "job-123";

    let task = image_api::api_v1_job_job_id_get(
        &config,
        job_id,
        Some(api_key),
    ).await?;

    println!("Status: {:?}", task.status);
    println!("Progress: {}%", task.progress.unwrap_or(0));

    if task.status == Some("completed".to_string()) {
        println!("Result: {:?}", task.output);
    }

    Ok(())
}

Polling for Completion

Wait for task completion with polling:

use legnext_rust_sdk::{
    apis::configuration::Configuration,
    apis::image_api,
};
use std::time::Duration;
use tokio::time::sleep;

async fn wait_for_completion(
    config: &Configuration,
    job_id: &str,
    api_key: &str,
    timeout_seconds: u64,
    poll_interval_seconds: u64,
) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
    let start_time = std::time::Instant::now();
    let timeout = Duration::from_secs(timeout_seconds);

    loop {
        let task = image_api::api_v1_job_job_id_get(
            config,
            job_id,
            Some(api_key),
        ).await?;

        println!("Current status: {:?}", task.status);

        if task.status == Some("completed".to_string()) {
            println!("Task completed successfully!");
            println!("Output: {:?}", task.output);
            return Ok(task.output.unwrap_or_default());
        } else if task.status == Some("failed".to_string()) {
            return Err(format!("Task failed: {:?}", task.error).into());
        }

        // Check timeout
        if start_time.elapsed() > timeout {
            return Err(format!("Task timeout after {} seconds", timeout_seconds).into());
        }

        // Wait before next poll
        sleep(Duration::from_secs(poll_interval_seconds)).await;
    }
}

Usage:

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut config = Configuration::new();
    config.base_path = "https://api.legnext.ai".to_string();

    let api_key = std::env::var("LEGNEXT_API_KEY")?;
    let job_id = "job-123";

    match wait_for_completion(&config, job_id, &api_key, 300, 3).await {
        Ok(result) => println!("Final result: {:?}", result),
        Err(e) => eprintln!("Error: {}", e),
    }

    Ok(())
}

Complete Example with Error Handling

use legnext_rust_sdk::{
    apis::configuration::Configuration,
    apis::image_api,
};
use std::collections::HashMap;
use std::time::Duration;
use tokio::time::sleep;

async fn wait_for_completion(
    config: &Configuration,
    job_id: &str,
    api_key: &str,
    timeout_seconds: u64,
    poll_interval_seconds: u64,
) -> Result<serde_json::Value, Box<dyn std::error::Error>> {
    let start_time = std::time::Instant::now();
    let timeout = Duration::from_secs(timeout_seconds);

    loop {
        let task = image_api::api_v1_job_job_id_get(
            config,
            job_id,
            Some(api_key),
        ).await?;

        if task.status == Some("completed".to_string()) {
            return Ok(task.output.unwrap_or_default());
        } else if task.status == Some("failed".to_string()) {
            return Err(format!("Task failed: {:?}", task.error).into());
        }

        if start_time.elapsed() > timeout {
            return Err(format!("Task timeout after {} seconds", timeout_seconds).into());
        }

        sleep(Duration::from_secs(poll_interval_seconds)).await;
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut config = Configuration::new();
    config.base_path = "https://api.legnext.ai".to_string();

    let api_key = std::env::var("LEGNEXT_API_KEY")
        .expect("LEGNEXT_API_KEY environment variable not set");

    // Step 1: Start generation
    let mut body = HashMap::new();
    body.insert("text".to_string(), "a beautiful sunset over mountains");

    let response = image_api::api_v1_diffusion_post(
        &config,
        Some(&api_key),
        Some(serde_json::to_value(body)?),
    ).await?;

    let job_id = response.job_id.ok_or("No job_id in response")?;
    println!("Job started: {}", job_id);

    // Step 2: Poll for completion
    let result = wait_for_completion(&config, &job_id, &api_key, 600, 3).await?;

    // Step 3: Get final result
    println!("Image URLs: {:?}", result);

    Ok(())
}

Error Handling

HTTP Error Handling: The Rust SDK returns Result types. Handle errors using pattern matching:

use legnext_rust_sdk::apis::Error;

match image_api::api_v1_diffusion_post(&config, Some(&api_key), Some(body)).await {
    Ok(response) => {
        println!("Success: {:?}", response);
    }
    Err(Error::ResponseError(ref content)) => {
        match content.status {
            400 => eprintln!("Validation error: {:?}", content.content),
            401 => eprintln!("Authentication error: Invalid API key"),
            404 => eprintln!("Resource not found"),
            429 => eprintln!("Rate limit exceeded. Please retry later."),
            500 | 502 | 503 => eprintln!("Server error: {:?}", content.content),
            _ => eprintln!("API error ({}): {:?}", content.status, content.content),
        }
    }
    Err(e) => eprintln!("Unexpected error: {:?}", e),
}

Common HTTP Status Codes:

Status Code	Description	Action
400	Invalid request parameters	Check request body format
401	Invalid API key	Verify API key is correct
404	Resource not found	Check job ID exists
429	Rate limit exceeded	Wait and retry with backoff
500/502/503	Server error	Retry with exponential backoff

Retry Logic with Exponential Backoff:

use std::time::Duration;
use tokio::time::sleep;

async fn call_with_retry<F, T>(
    api_call: F,
    max_retries: u32,
) -> Result<T, Box<dyn std::error::Error>>
where
    F: Fn() -> futures::future::BoxFuture<'static, Result<T, legnext_rust_sdk::apis::Error>>,
{
    for i in 0..max_retries {
        match api_call().await {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(ref content)) => {
                if content.status == 429 {
                    // Rate limited - wait and retry
                    sleep(Duration::from_secs(5)).await;
                    continue;
                } else if content.status >= 500 {
                    // Server error - exponential backoff
                    let delay = Duration::from_secs(2_u64.pow(i));
                    sleep(delay).await;
                    if i == max_retries - 1 {
                        return Err(Box::new(content.clone()));
                    }
                    continue;
                } else {
                    // Other errors - don't retry
                    return Err(Box::new(content.clone()));
                }
            }
            Err(e) => return Err(Box::new(e)),
        }
    }
    Err("Max retries exceeded".into())
}

// Usage
let result = call_with_retry(
    || Box::pin(image_api::api_v1_diffusion_post(&config, Some(&api_key), Some(body.clone()))),
    3,
).await?;

Concurrent Operations with Tokio

For processing multiple tasks concurrently:

use tokio::try_join;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut config = Configuration::new();
    config.base_path = "https://api.legnext.ai".to_string();

    let api_key = std::env::var("LEGNEXT_API_KEY")?;

    let prompts = vec!["sunset", "mountains", "ocean"];

    // Start all generations concurrently
    let mut handles = vec![];

    for prompt in prompts {
        let config_clone = config.clone();
        let api_key_clone = api_key.clone();
        let prompt_clone = prompt.to_string();

        let handle = tokio::spawn(async move {
            let mut body = HashMap::new();
            body.insert("text".to_string(), prompt_clone.clone());

            let response = image_api::api_v1_diffusion_post(
                &config_clone,
                Some(&api_key_clone),
                Some(serde_json::to_value(body)?),
            ).await?;

            let job_id = response.job_id.ok_or("No job_id")?;

            // Wait for completion
            let result = wait_for_completion(
                &config_clone,
                &job_id,
                &api_key_clone,
                600,
                3,
            ).await?;

            Ok::<_, Box<dyn std::error::Error>>(result)
        });

        handles.push(handle);
    }

    // Wait for all tasks to complete
    for handle in handles {
        match handle.await {
            Ok(Ok(result)) => println!("Image generated: {:?}", result),
            Ok(Err(e)) => eprintln!("Task error: {}", e),
            Err(e) => eprintln!("Join error: {}", e),
        }
    }

    Ok(())
}

Progress Callbacks

use std::sync::Arc;
use tokio::sync::Mutex;

async fn wait_for_completion_with_progress<F>(
    config: &Configuration,
    job_id: &str,
    api_key: &str,
    on_progress: F,
    timeout_seconds: u64,
    poll_interval_seconds: u64,
) -> Result<serde_json::Value, Box<dyn std::error::Error>>
where
    F: Fn(i32, &str),
{
    let start_time = std::time::Instant::now();
    let timeout = Duration::from_secs(timeout_seconds);

    loop {
        let task = image_api::api_v1_job_job_id_get(
            config,
            job_id,
            Some(api_key),
        ).await?;

        // Call progress callback
        on_progress(
            task.progress.unwrap_or(0),
            task.status.as_deref().unwrap_or("unknown"),
        );

        if task.status == Some("completed".to_string()) {
            return Ok(task.output.unwrap_or_default());
        } else if task.status == Some("failed".to_string()) {
            return Err(format!("Task failed: {:?}", task.error).into());
        }

        if start_time.elapsed() > timeout {
            return Err(format!("Task timeout after {} seconds", timeout_seconds).into());
        }

        sleep(Duration::from_secs(poll_interval_seconds)).await;
    }
}

// Usage
let result = wait_for_completion_with_progress(
    &config,
    &job_id,
    &api_key,
    |progress, status| {
        println!("Progress: {}% - Status: {}", progress, status);
    },
    600,
    3,
).await?;

Overview

Client Libraries

api_v1_job_job_id_get()

Polling for Completion

Complete Example with Error Handling

Error Handling

Concurrent Operations with Tokio

Progress Callbacks

Learn More

​api_v1_job_job_id_get()

​Polling for Completion

​Complete Example with Error Handling

​Error Handling

​Concurrent Operations with Tokio

​Progress Callbacks

​Learn More

api_v1_job_job_id_get()

Polling for Completion

Complete Example with Error Handling

Error Handling

Concurrent Operations with Tokio

Progress Callbacks

Learn More