Struct Ai 

pub struct Ai(/* private fields */);

Enables access to Workers AI functionality.

Implementations

impl Ai

pub async fn run<T: Serialize, U: DeserializeOwned>( &self, model: impl AsRef<str>, input: T, ) -> Result<U>

Execute a Workers AI operation using the specified model. Various forms of the input are documented in the Workers AI documentation.

pub async fn run_bytes<T: Serialize>( &self, model: impl AsRef<str>, input: T, ) -> Result<ByteStream>

Execute a Workers AI operation that returns binary data as a ByteStream.

This method is designed for AI models that return raw bytes, such as:

• Image generation models (e.g., Stable Diffusion)
• Text-to-speech models
• Any other model that returns binary output

The returned ByteStream implements Stream and can be:

• Streamed directly to a [Response] using [Response::from_stream]
• Collected into a Vec<u8> by iterating over the chunks

Examples

Streaming directly to a response (recommended)

This approach is more memory-efficient as it doesn’t buffer the entire response in memory:

use worker::*;
use serde::Serialize;

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

async fn generate_image(env: &Env) -> Result<Response> {
    let ai = env.ai("AI")?;
    let request = ImageGenRequest {
        prompt: "a beautiful sunset".to_string(),
    };
    let stream = ai.run_bytes(
        "@cf/stabilityai/stable-diffusion-xl-base-1.0",
        &request
    ).await?;

    // Stream directly to the response
    let mut response = Response::from_stream(stream)?;
    response.headers_mut().set("Content-Type", "image/png")?;
    Ok(response)
}

Collecting into bytes

Use this approach if you need to inspect or modify the bytes before sending:

use worker::*;
use serde::Serialize;
use futures_util::StreamExt;

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

async fn generate_image(env: &Env) -> Result<Response> {
    let ai = env.ai("AI")?;
    let request = ImageGenRequest {
        prompt: "a beautiful sunset".to_string(),
    };
    let mut stream = ai.run_bytes(
        "@cf/stabilityai/stable-diffusion-xl-base-1.0",
        &request
    ).await?;

    // Collect all chunks into a Vec<u8>
    let mut bytes = Vec::new();
    while let Some(chunk) = stream.next().await {
        bytes.extend_from_slice(&chunk?);
    }

    let mut response = Response::from_bytes(bytes)?;
    response.headers_mut().set("Content-Type", "image/png")?;
    Ok(response)
}

Trait Implementations

impl AsRef<JsValue> for Ai

fn as_ref(&self) -> &JsValue

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for Ai

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EnvBinding for Ai

const TYPE_NAME: &'static str = "Ai"

fn get(val: JsValue) -> Result<Self>

impl From<Ai> for Ai

fn from(inner: AiSys) -> Self

Converts to this type from the input type.

impl From<Ai> for JsValue

fn from(database: Ai) -> Self

Converts to this type from the input type.

impl JsCast for Ai

fn instanceof(val: &JsValue) -> bool

Performs a dynamic instanceof check to see whether the JsValue provided is an instance of this type.

fn unchecked_from_js(val: JsValue) -> Self

Performs a zero-cost unchecked conversion from a JsValue into an instance of Self

fn unchecked_from_js_ref(val: &JsValue) -> &Self

Performs a zero-cost unchecked conversion from a &JsValue into an instance of &Self.

fn has_type<T>(&self) -> bool

where T: JsCast,

Test whether this JS value has a type T.

fn dyn_into<T>(self) -> Result<T, Self>

where T: JsCast,

Performs a dynamic cast (checked at runtime) of this value into the target type T.

fn dyn_ref<T>(&self) -> Option<&T>

where T: JsCast,

Performs a dynamic cast (checked at runtime) of this value into the target type T.

fn unchecked_into<T>(self) -> T

where T: JsCast,

Performs a zero-cost unchecked cast into the specified type.

fn unchecked_ref<T>(&self) -> &T

where T: JsCast,

Performs a zero-cost unchecked cast into a reference to the specified type.

fn is_instance_of<T>(&self) -> bool

where T: JsCast,

Test whether this JS value is an instance of the type T.

fn is_type_of(val: &JsValue) -> bool

Performs a dynamic check to see whether the JsValue provided is a value of this type.

impl Send for Ai

impl Sync for Ai