use serde_json::{json, Value};
use std::fmt;
use std::thread::sleep;
use std::time::{Duration, Instant};
pub const BASE_URL: &str = "https://saymaker.ai";
pub const KEYS_URL: &str = "https://saymaker.ai/settings/apikeys";
pub const MODEL_IMAGE: &str = "saymaker-image-v1";
pub const MODEL_EDIT: &str = "nano-banana-2-lite";
pub const MODEL_VIDEO: &str = "minimax-h3-fast";
pub const MODELS: &[(&str, &str)] = &[
("saymaker-image-v1", "kie"), ("nano-banana-2-lite", "kie"), ("nano-banana-2", "poyo"),
("nano-banana-pro", "poyo"), ("gpt-image-2", "poyo"), ("gpt-image-2-5-flare", "kie"),
("seedream-5-lite", "poyo"), ("seedream-5-pro", "kie"), ("qwen-image-3-pro", "kie"),
("grok-imagine-image-2-0", "poyo"), ("minimax-h3-fast", "vgenv"), ("minimax-h3", "poyo"),
("seedance-2", "kie"), ("seedance-2-fast", "kie"), ("seedance-2-5", "kie"), ("veo-3-1", "kie"),
("kling-3-0", "kie"), ("kling-3-0-turbo", "kie"), ("wan-3-0", "kie"), ("ltx-2-5-fast", "replicate"),
];
#[derive(Debug)]
pub enum Error {
Auth(String),
Quota(String),
Plan(String),
Busy(String),
Rejected,
Timeout,
Other(String),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::Auth(m) if m.contains("settings/apikeys") => write!(f, "saymaker: {m}"),
Error::Auth(m) => write!(f, "saymaker: {m} (create a key at {KEYS_URL})"),
Error::Quota(m) | Error::Plan(m) | Error::Busy(m) | Error::Other(m) => write!(f, "saymaker: {m}"),
Error::Rejected => write!(f, "saymaker: the run failed; reword the prompt rather than retrying"),
Error::Timeout => write!(f, "saymaker: deadline passed"),
}
}
}
impl std::error::Error for Error {}
#[derive(Clone, Debug, Default)]
pub struct Options {
pub api_key: Option<String>,
pub model: Option<String>,
pub image_url: Option<String>,
pub aspect_ratio: Option<String>,
pub timeout: Option<Duration>,
}
#[derive(Clone, Debug, Default)]
pub struct VideoOptions {
pub api_key: Option<String>,
pub model: Option<String>,
pub image_url: Option<String>,
pub duration: Option<u32>,
pub resolution: Option<String>,
pub aspect_ratio: Option<String>,
pub no_sound: bool,
pub timeout: Option<Duration>,
}
pub fn generate(prompt: &str, opts: &Options) -> Result<String, Error> {
let edit = opts.image_url.clone();
check_url(&edit)?;
let model = opts.model.clone().unwrap_or_else(|| if edit.is_some() { MODEL_EDIT } else { MODEL_IMAGE }.into());
let size = opts.aspect_ratio.clone().unwrap_or_else(|| if edit.is_some() { "auto" } else { "1:1" }.into());
let mut o = json!({ "size": size, "resolution": "1K", "n": 1 });
if let Some(u) = &edit {
o["image_input"] = json!([u]);
}
let scene = if edit.is_some() { "image-to-image" } else { "text-to-image" };
run(opts.api_key.clone(), "image", scene, &model, prompt, o, Duration::from_secs(5), opts.timeout.unwrap_or(Duration::from_secs(4500)))
}
pub fn generate_video(prompt: &str, opts: &VideoOptions) -> Result<String, Error> {
check_url(&opts.image_url)?;
let model = opts.model.clone().unwrap_or_else(|| MODEL_VIDEO.into());
let mut o = json!({ "aspect_ratio": opts.aspect_ratio.clone().unwrap_or_else(|| "16:9".into()), "sound": !opts.no_sound });
if let Some(u) = &opts.image_url {
o["image_input"] = json!([u]);
}
if let Some(d) = opts.duration {
o["duration"] = json!(d);
}
if let Some(r) = &opts.resolution {
o["resolution"] = json!(r);
}
let scene = if opts.image_url.is_some() { "image-to-video" } else { "text-to-video" };
run(opts.api_key.clone(), "video", scene, &model, prompt, o, Duration::from_secs(10), opts.timeout.unwrap_or(Duration::from_secs(5400)))
}
fn check_url(u: &Option<String>) -> Result<(), Error> {
match u {
Some(s) if !(s.starts_with("http://") || s.starts_with("https://")) => {
Err(Error::Other("image_url must be a public http(s) url".into()))
}
_ => Ok(()),
}
}
pub fn provider_for(model: &str) -> &'static str {
MODELS.iter().find(|(m, _)| *m == model).map(|(_, p)| *p).unwrap_or("kie")
}
#[allow(clippy::too_many_arguments)]
fn run(key: Option<String>, media: &str, scene: &str, model: &str, prompt: &str, options: Value, poll: Duration, timeout: Duration) -> Result<String, Error> {
if prompt.trim().is_empty() {
return Err(Error::Other("prompt is required".into()));
}
let key = key.filter(|k| !k.is_empty()).or_else(|| std::env::var("SAYMAKER_API_KEY").ok().filter(|k| !k.is_empty()))
.ok_or_else(|| Error::Auth("an API key is required".into()))?;
let base = std::env::var("SAYMAKER_BASE_URL").unwrap_or_else(|_| BASE_URL.into());
let body = json!({
"provider": provider_for(model), "mediaType": media, "model": model,
"scene": scene, "prompt": prompt, "options": options,
});
let data = post(&base, &key, "/api/ai/generate", body)?;
if data.get("wall").and_then(Value::as_bool).unwrap_or(false) {
return Err(Error::Auth("an API key is required".into()));
}
let id = data.get("id").and_then(Value::as_str).ok_or_else(|| Error::Other("no task id".into()))?.to_string();
let deadline = Instant::now() + timeout;
while Instant::now() < deadline {
sleep(poll);
let d = match post(&base, &key, "/api/ai/query", json!({ "taskId": id })) {
Ok(d) => d,
Err(e @ Error::Auth(_)) => return Err(e),
Err(_) => continue, };
if let Some(url) = first_url(&d) {
return Ok(url);
}
let status = d.get("status").and_then(Value::as_str).unwrap_or("").to_lowercase();
if status == "failed" || status == "error" {
return Err(Error::Rejected);
}
}
Err(Error::Timeout)
}
pub fn first_url(data: &Value) -> Option<String> {
["cleanImages", "images", "videos"].iter().find_map(|f| data.get(*f)?.get(0)?.as_str().map(String::from))
}
fn post(base: &str, key: &str, path: &str, body: Value) -> Result<Value, Error> {
let resp = ureq::post(&format!("{base}{path}"))
.set("Authorization", &format!("Bearer {key}"))
.set("User-Agent", "saymaker-rust/0.1.0")
.send_json(body);
let env: Value = match resp {
Ok(r) => r.into_json().map_err(|e| Error::Other(e.to_string()))?,
Err(ureq::Error::Status(_, r)) => r.into_json().unwrap_or(Value::Null),
Err(e) => return Err(Error::Other(e.to_string())),
};
if env.get("code").and_then(Value::as_i64) != Some(0) {
return Err(classify(env.get("message").and_then(Value::as_str).unwrap_or("request refused")));
}
Ok(env.get("data").cloned().unwrap_or(Value::Null))
}
pub fn classify(msg: &str) -> Error {
let low = msg.to_lowercase();
if low.contains("is rendering") || low.contains("at once") {
Error::Busy(msg.into())
} else if low.contains("api key") || low.contains("no auth") {
Error::Auth(msg.into())
} else if low.contains("insufficient credits") {
Error::Quota(msg.into())
} else if low.contains("subscription") || low.contains("plan") || low.contains("sign in") {
Error::Plan(msg.into())
} else {
Error::Other(msg.into())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn routes_and_classifies() {
assert_eq!(provider_for("minimax-h3-fast"), "vgenv");
assert_eq!(provider_for("unknown"), "kie");
assert!(matches!(classify("insufficient credits"), Error::Quota(_)));
assert!(matches!(classify("invalid API key"), Error::Auth(_)));
assert!(matches!(classify("Your current run is rendering. Plans on the pricing page"), Error::Busy(_)));
let d = json!({"images": ["m"], "cleanImages": ["c"]});
assert_eq!(first_url(&d).as_deref(), Some("c"));
assert_eq!(first_url(&json!({"videos": ["v"]})).as_deref(), Some("v"));
}
#[test]
fn rejects_bad_input() {
let o = Options { image_url: Some("file:///x".into()), ..Default::default() };
assert!(generate("x", &o).is_err());
std::env::remove_var("SAYMAKER_API_KEY");
assert!(matches!(generate("x", &Options::default()), Err(Error::Auth(_))));
}
}