Struct DiffusionProvider 

pub struct DiffusionProvider { /* private fields */ }

A local image generation provider backed by diffusion-rs.

Constructed via DiffusionProvider::from_options. With the engine feature on, [DiffusionProvider::generate_image] lazily initialises the underlying pipeline on first call and runs the synchronous stable-diffusion.cpp generation inside tokio::task::spawn_blocking.

Implementations

impl DiffusionProvider

pub fn from_options(opts: DiffusionOptions) -> Result<Self, DiffusionError>

Create a new provider from the given options.

This currently validates the options and stores them. The actual diffusion-rs pipeline will be initialised in Phase 5.3.

Errors

Returns DiffusionError::InvalidOptions if any option is present but invalid (e.g. an empty device string, zero dimensions, or zero steps).

pub fn device_str(&self) -> &str

The resolved device string ("cpu" when unset).

pub fn model_id(&self) -> &str

The configured model identifier (or "sd-1.5" when unset).

pub fn width(&self) -> u32

The resolved width (user-specified or default 512).

pub fn height(&self) -> u32

The resolved height (user-specified or default 512).

pub fn num_inference_steps(&self) -> u32

The resolved number of inference steps (user-specified or default 20).

pub fn guidance_scale(&self) -> f32

The resolved guidance scale (user-specified or default 7.5).

pub const fn scheduler(&self) -> DiffusionScheduler

The scheduler configured for this provider.

pub async fn load(&self) -> Result<(), DiffusionError>

Eagerly warm the underlying diffusion-rs pipeline.

Without the engine feature this returns DiffusionError::EngineNotAvailable. With it, this is idempotent and safe to call from multiple tasks concurrently.

Errors

Returns DiffusionError::ModelLoad if pipeline construction or the output-directory bootstrap fails.

pub async fn unload(&self) -> Result<(), DiffusionError>

Best-effort unload. Always succeeds.

diffusion-rs does not expose a “drop weights” entry point and the cached pipeline lives behind a tokio::sync::OnceCell shared via &self, so we cannot evict it from interior mutability alone. Callers that require strict resource release should drop the entire DiffusionProvider and construct a fresh one.

Errors

Never errors today; the Result is kept to match the [blazen_llm::LocalModel::unload] trait signature so the bridge can forward without contortions.

pub async fn is_loaded(&self) -> bool

true if a pipeline has been warmed via Self::load or the first generate call.

Trait Implementations

impl ComputeProvider for DiffusionProvider

fn provider_id(&self) -> &str

Provider identifier (e.g., “fal”, “replicate”, “runpod”).

fn submit<'life0, 'async_trait>( &'life0 self, _request: ComputeRequest, ) -> Pin<Box<dyn Future<Output = Result<JobHandle, BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Submit a compute job and get a handle to track it.

fn status<'life0, 'life1, 'async_trait>( &'life0 self, _job: &'life1 JobHandle, ) -> Pin<Box<dyn Future<Output = Result<JobStatus, BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Poll the current status of a submitted job.

fn result<'life0, 'async_trait>( &'life0 self, _job: JobHandle, ) -> Pin<Box<dyn Future<Output = Result<ComputeResult, BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Wait for a job to complete and return the result.

fn cancel<'life0, 'life1, 'async_trait>( &'life0 self, _job: &'life1 JobHandle, ) -> Pin<Box<dyn Future<Output = Result<(), BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cancel a running or queued job.

fn run<'life0, 'async_trait>( &'life0 self, request: ComputeRequest, ) -> Pin<Box<dyn Future<Output = Result<ComputeResult, BlazenError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Submit a job and wait for the result (convenience method).

fn provider_config(&self) -> Option<&ProviderConfig>

Optional configuration metadata for this provider.

impl ImageGeneration for DiffusionProvider

fn generate_image<'life0, 'async_trait>( &'life0 self, request: ImageRequest, ) -> Pin<Box<dyn Future<Output = Result<ImageResult, BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Generate images from a text prompt.

fn upscale_image<'life0, 'async_trait>( &'life0 self, _request: UpscaleRequest, ) -> Pin<Box<dyn Future<Output = Result<ImageResult, BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Upscale an existing image.

fn edit_image<'life0, 'async_trait>( &'life0 self, _request: ImageEditRequest, ) -> Pin<Box<dyn Future<Output = Result<ImageResult, BlazenError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Edit an existing image (img2img, inpaint, outpaint, etc.).

impl LocalModel for DiffusionProvider

LocalModel bridge: gives ModelManager explicit load/unload control over the underlying diffusion-rs pipeline. The implementation forwards to the inherent methods on DiffusionProvider and wraps DiffusionError into BlazenError::Provider via [map_err].

fn load<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load the model into memory. Idempotent – if the model is already loaded, this is a no-op that returns Ok(()).

fn unload<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Drop the loaded model and free its memory. Idempotent – if the model is already unloaded, this is a no-op that returns Ok(()).

fn is_loaded<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Whether the model is currently loaded in memory.

fn device(&self) -> Device

Which device the model is configured to run on. Determines which memory pool the ModelManager charges this model against. Defaults to Device::Cpu for backwards compatibility with implementors that have not yet declared a target.

fn load_adapter<'life0, 'life1, 'async_trait>( &'life0 self, _adapter_dir: &'life1 Path, _options: AdapterOptions, ) -> Pin<Box<dyn Future<Output = Result<AdapterHandle, BlazenError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mount a PEFT-format LoRA adapter onto the loaded base model.

fn memory_bytes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<u64>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Approximate memory footprint in bytes (host RAM if Self::device returns Device::Cpu, GPU VRAM otherwise). Returns None for implementations that can’t measure.

fn unload_adapter<'life0, 'life1, 'async_trait>( &'life0 self, _handle: &'life1 AdapterHandle, ) -> Pin<Box<dyn Future<Output = Result<(), BlazenError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Remove a previously-mounted adapter. Default impl returns BlazenError::unsupported for the same reason as Self::load_adapter.

fn list_adapters<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Vec<AdapterStatus>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

List currently-mounted adapters. The default returns an empty Vec because “no adapters mounted” is a truthful state for any backend — adapter capability is probed via Self::load_adapter.