qai-sdk 0.1.23

Universal Rust SDK for AI Providers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! # xAI Video Generation
//!
//! xAI Video generation provider implementation.

use crate::core::types::{VideoGenerateOptions, VideoGenerateResult};
use anyhow::anyhow;
use async_trait::async_trait;
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::time::Duration;
use tokio::time::sleep;

/// xAI video generation model.
pub struct XaiVideoModel {
    pub api_key: String,
    pub base_url: String,
    pub client: Client,
}

impl XaiVideoModel {
    #[must_use]
    pub fn new(api_key: String, base_url: String) -> Self {
        Self {
            api_key,
            base_url,
            client: Client::new(),
        }
    }
}

#[derive(Serialize)]
struct XaiVideoRequest {
    model: String,
    prompt: String,
}

#[derive(Deserialize)]
struct XaiVideoResponse {
    request_id: String,
}

#[derive(Deserialize)]
struct XaiVideoStatusResponse {
    status: String,
    video: Option<XaiVideoDetail>,
}

#[derive(Deserialize)]
struct XaiVideoDetail {
    url: String,
}

#[async_trait]
impl crate::core::VideoModel for XaiVideoModel {
    async fn generate(&self, options: VideoGenerateOptions) -> crate::core::Result<VideoGenerateResult> {
        let request = XaiVideoRequest {
            model: options.model_id,
            prompt: options.prompt,
        };

        let resp = self
            .client
            .post(format!("{}/videos/generations", self.base_url))
            .header("Authorization", &format!("Bearer {}", self.api_key))
            .json(&request)
            .send()
            .await?;

        if !resp.status().is_success() {
            let error_text = resp.text().await?;
            return Err(anyhow!("xAI Video Generation API error: {error_text}").into());
        }

        let submission: XaiVideoResponse = resp.json().await?;
        let request_id = submission.request_id;

        // Poll for completion (up to 2 minutes)
        for _ in 0..24 {
            sleep(Duration::from_secs(5)).await;

            let status_resp = self
                .client
                .get(format!("{}/videos/{}", self.base_url, request_id))
                .header("Authorization", &format!("Bearer {}", self.api_key))
                .send()
                .await?;

            if !status_resp.status().is_success() {
                continue;
            }

            let status: XaiVideoStatusResponse = status_resp.json().await?;
            if status.status == "done" {
                if let Some(video) = status.video {
                    return Ok(VideoGenerateResult {
                        url: Some(video.url),
                        data: None,
                        revision: Some(request_id),
                    });
                }
            } else if status.status == "failed" {
                return Err(anyhow!("xAI Video Generation failed for ID: {}", request_id).into());
            }
        }

        Err(anyhow!("xAI Video Generation timed out for ID: {}", request_id).into())
    }
}