Rust SDK

[dependencies]
moonborn = "1.0"
tokio = { version = "1", features = ["full"] }
futures = "0.3"

cargo build

use moonborn::{Client, CreatePersonaInput, Result};
use std::env;
 
#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::new(env::var("MOONBORN_API_KEY")?);
    // veya:
    // let client = Client::builder()
    //     .api_key(env::var("MOONBORN_API_KEY")?)
    //     .base_url("https://api.moonborn.co")  // kendi sunucuna kurulum
    //     .timeout(Duration::from_secs(60))
    //     .build()?;
 
    let persona = client.personas()
        .create_persona(CreatePersonaInput {
            intent: "İstanbul'dan 34 yaşında bir kurucu. Parlak ama huzursuz.".into(),
            workspace_id: "ws_...".into(),
            ..Default::default()
        })
        .await?;
 
    println!("{} {}", persona.id, persona.status);
    Ok(())
}

use futures::StreamExt;
use moonborn::{StreamMessageInput, Chunk};
 
let session = client.chat().create_session(/* ... */).await?;
 
let mut stream = client.chat()
    .stream_message(StreamMessageInput {
        session_id: session.id.clone(),
        content: "Sessiz bir gerçek söyle.".into(),
    })
    .await?;
 
while let Some(chunk) = stream.next().await {
    match chunk? {
        Chunk::Token { delta } => print!("{}", delta),
        Chunk::Completed { drift_score, .. } => {
            println!("\ndrift: {}", drift_score);
        }
        Chunk::Error { error } => {
            eprintln!("stream error: {}", error);
        }
    }
}

use moonborn::Event;
 
let mut stream = client.personas()
    .create_persona_stream(CreatePersonaInput {
        intent: "Lagos'ta bir market satıcısı.".into(),
        ..Default::default()
    })
    .await?;
 
while let Some(event) = stream.next().await {
    match event? {
        Event::StepStarted { step } => println!("Başladı: {}", step),
        Event::StepCompleted { step, duration_ms } => {
            println!("Bitti: {} ({}ms)", step, duration_ms);
        }
        Event::PipelineCompleted { persona_id, .. } => {
            println!("Persona: {}", persona_id);
        }
    }
}

use moonborn::{Error, GetPersonaInput};
 
match client.personas().get_persona(GetPersonaInput {
    id: "per_...".into()
}).await {
    Ok(persona) => {
        println!("{}", persona.id);
    }
    Err(Error::Api(api_err)) => {
        match api_err.code.as_str() {
            "rate_limited" => {
                let wait = api_err.retry_after.unwrap_or(Duration::from_secs(1));
                tokio::time::sleep(wait).await;
                // yeniden dene
            }
            "not_found" => {
                eprintln!("persona missing");
            }
            "validation_failed" => {
                eprintln!("invalid body: {:?}", api_err.details);
            }
            _ => return Err(Error::Api(api_err).into()),
        }
    }
    Err(Error::Network(e)) => {
        eprintln!("network: {}", e);
    }
    Err(e) => return Err(e.into()),
}

use moonborn::{Client, RetryConfig};
use std::time::Duration;
 
let client = Client::builder()
    .api_key(env::var("MOONBORN_API_KEY")?)
    .retry_config(RetryConfig {
        max_retries: 5,
        initial_wait: Duration::from_millis(500),
        max_wait: Duration::from_secs(30),
    })
    .build()?;

use moonborn::RequestOptions;
 
let persona = client.personas()
    .create_persona_with_options(
        CreatePersonaInput { intent: "...".into(), ..Default::default() },
        RequestOptions::default()
            .with_idempotency_key("persona-build-2026-05-17-mert"),
    )
    .await?;

#[tokio::main]
async fn main() { /* ... */ }
 
// veya elle:
let rt = tokio::runtime::Runtime::new()?;
rt.block_on(async { /* ... */ });