use serde::Deserialize;
use serde_json::{json, Value};
use std::fmt;
use std::thread::sleep;
use std::time::{Duration, Instant};
pub const BASE_URL: &str = "https://veida.ai";
pub const ANON_GRANT: u32 = 4;
pub const COST_TEXT_TO_IMAGE: u32 = 4;
pub const IP_DAILY_CEILING: u32 = 30;
pub const MODEL: &str = "veida-image-v1";
pub const ASPECT_RATIOS: [&str; 5] = ["1:1", "16:9", "9:16", "4:3", "3:4"];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Image {
pub url: String,
pub watermarked: bool,
}
#[derive(Debug, Clone)]
pub struct Options {
pub aspect_ratio: String,
pub poll_every: Duration,
pub timeout: Duration,
pub base_url: String,
}
impl Default for Options {
fn default() -> Self {
Options {
aspect_ratio: "1:1".into(),
poll_every: Duration::from_secs(4),
timeout: Duration::from_secs(240),
base_url: BASE_URL.into(),
}
}
}
#[derive(Debug)]
pub enum Error {
Invalid(String),
Quota(String),
Rejected,
Timeout,
Service(String),
Transport(String),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::Invalid(m) => write!(f, "veida: {m}"),
Error::Quota(m) => write!(f, "veida: free allowance spent: {m} (sign in at https://veida.ai/pricing)"),
Error::Rejected => write!(f, "veida: prompt refused by the content filter; reword it rather than retrying"),
Error::Timeout => write!(f, "veida: deadline passed while the job was still queued"),
Error::Service(m) => write!(f, "veida: {m}"),
Error::Transport(m) => write!(f, "veida: transport: {m}"),
}
}
}
impl std::error::Error for Error {}
#[derive(Deserialize)]
struct Envelope {
code: i64,
#[serde(default)]
message: String,
#[serde(default)]
data: Value,
}
pub fn anon_id() -> String {
let mut b = [0u8; 8];
if getrandom::getrandom(&mut b).is_err() {
let n = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
return format!("rs-{n}");
}
let hex: String = b.iter().map(|x| format!("{x:02x}")).collect();
format!("rs-{hex}")
}
pub fn generate(prompt: &str, opts: &Options) -> Result<Image, Error> {
if prompt.trim().is_empty() {
return Err(Error::Invalid("prompt is required".into()));
}
let ratio = if opts.aspect_ratio.is_empty() { "1:1" } else { opts.aspect_ratio.as_str() };
if !ASPECT_RATIOS.contains(&ratio) {
return Err(Error::Invalid(format!("aspect_ratio must be one of {}", ASPECT_RATIOS.join(", "))));
}
let started = Instant::now();
let agent = ureq::AgentBuilder::new()
.timeout(opts.timeout.min(Duration::from_secs(60)))
.user_agent(concat!("veida-rs/", env!("CARGO_PKG_VERSION")))
.build();
let id = anon_id();
let env = read(
agent
.post(&format!("{}/api/ai/generate", opts.base_url))
.set("x-anon-id", &id)
.send_json(json!({
"provider": "kie", "mediaType": "image", "model": MODEL,
"scene": "text-to-image", "prompt": prompt,
"options": { "aspect_ratio": ratio }
})),
)?;
let task = parse_submit(env.code, &env.message, &env.data)?;
loop {
if started.elapsed() >= opts.timeout {
return Err(Error::Timeout);
}
sleep(opts.poll_every);
let polled = agent
.get(&format!(
"{}/api/ai/anon-query?taskId={}&provider=kie&mediaType=image",
opts.base_url, task
))
.set("x-anon-id", &id)
.call();
let env = match read(polled) {
Ok(e) if e.code == 0 => e,
_ => continue,
};
if let Some(img) = parse_poll(&env.data)? {
return Ok(img);
}
}
}
fn read(resp: Result<ureq::Response, ureq::Error>) -> Result<Envelope, Error> {
let resp = match resp {
Ok(r) => r,
Err(ureq::Error::Status(_, r)) => r,
Err(e) => return Err(Error::Transport(e.to_string())),
};
resp.into_json::<Envelope>().map_err(|e| Error::Transport(e.to_string()))
}
pub fn parse_submit(code: i64, message: &str, data: &Value) -> Result<String, Error> {
if code != 0 {
return Err(Error::Service(message.to_string()));
}
if data.get("wall").and_then(Value::as_bool).unwrap_or(false) {
return match data.get("reason").and_then(Value::as_str).unwrap_or("") {
"anon_ip_daily" => Err(Error::Quota(format!(
"this machine has used its {IP_DAILY_CEILING} credits for today"
))),
other => Err(Error::Quota(other.to_string())),
};
}
match data.get("id").and_then(Value::as_str) {
Some(id) if !id.is_empty() => Ok(id.to_string()),
_ => Err(Error::Service("the service returned no task id".into())),
}
}
pub fn parse_poll(data: &Value) -> Result<Option<Image>, Error> {
if let Some(url) = data.get("images").and_then(|v| v.get(0)).and_then(Value::as_str) {
let watermarked = data
.get("watermarked")
.and_then(|v| v.get(0))
.and_then(Value::as_bool)
.unwrap_or(false);
return Ok(Some(Image { url: url.to_string(), watermarked }));
}
match data.get("status").and_then(Value::as_str).map(str::to_lowercase).as_deref() {
Some("failed") | Some("error") => Err(Error::Rejected),
_ => Ok(None),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ids_are_unique() {
assert_ne!(anon_id(), anon_id());
assert!(anon_id().starts_with("rs-"));
}
#[test]
fn validates_arguments() {
let o = Options::default();
assert!(matches!(generate(" ", &o), Err(Error::Invalid(_))));
let bad = Options { aspect_ratio: "2:1".into(), ..Default::default() };
assert!(matches!(generate("x", &bad), Err(Error::Invalid(_))));
}
#[test]
fn wall_is_a_200_recognised_by_field() {
let d = json!({"wall": true, "reason": "anon_ip_daily"});
assert!(matches!(parse_submit(0, "ok", &d), Err(Error::Quota(_))));
let d = json!({"wall": true, "reason": "anon_credits"});
assert!(matches!(parse_submit(0, "ok", &d), Err(Error::Quota(_))));
}
#[test]
fn task_id_and_poll() {
assert_eq!(parse_submit(0, "ok", &json!({"id": "t1"})).unwrap(), "t1");
assert!(parse_poll(&json!({"status": "processing"})).unwrap().is_none());
assert!(matches!(parse_poll(&json!({"status": "FAILED"})), Err(Error::Rejected)));
let img = parse_poll(&json!({"images": ["https://cdn/x.webp"], "watermarked": [true]})).unwrap().unwrap();
assert!(img.watermarked);
}
}