blazen_llm_core/compute/

traits.rs

//! Compute platform traits for media generation providers.
//!
//! Implement [`ComputeProvider`] as the base, then add media-specific
//! traits ([`ImageGeneration`], [`VideoGeneration`], etc.) for the
//! capabilities your provider supports.
//!
//! ```rust,ignore
//! use blazen_llm_core::compute::*;
//! use blazen_llm_core::BlazenError;
//!
//! struct MyImageProvider { /* ... */ }
//!
//! #[async_trait::async_trait]
//! impl ComputeProvider for MyImageProvider {
//!     fn provider_id(&self) -> &str { "my-provider" }
//!     async fn submit(&self, request: ComputeRequest) -> Result<JobHandle, BlazenError> { todo!() }
//!     async fn status(&self, job: &JobHandle) -> Result<JobStatus, BlazenError> { todo!() }
//!     async fn result(&self, job: JobHandle) -> Result<ComputeResult, BlazenError> { todo!() }
//!     async fn cancel(&self, job: &JobHandle) -> Result<(), BlazenError> { todo!() }
//! }
//!
//! #[async_trait::async_trait]
//! impl ImageGeneration for MyImageProvider {
//!     async fn generate_image(&self, request: ImageRequest) -> Result<ImageResult, BlazenError> {
//!         // Your implementation
//!         todo!()
//!     }
//!     async fn upscale_image(&self, request: UpscaleRequest) -> Result<ImageResult, BlazenError> {
//!         // Your implementation
//!         todo!()
//!     }
//! }
//! ```

use std::sync::Arc;

use async_trait::async_trait;

use super::job::{ComputeRequest, ComputeResult, JobHandle, JobStatus};
use super::requests::{
    BackgroundRemovalRequest, CadReconstructionRequest, CadRequest, CaptionRequest, DepthRequest,
    DetectionRequest, EmbeddingRequest, ImageEditRequest, ImageRequest, MusicRequest,
    ReconstructionRequest, RetopologyRequest, SegmentationRequest, SpeechRequest, TextureRequest,
    ThreeDRequest, TranscriptionRequest, UpscaleRequest, VideoEditRequest, VideoRequest,
    VoiceCloneRequest,
};
use super::results::{
    AudioResult, CadReconstructionResult, CadResult, CaptionResult, DepthResult, DetectionResult,
    EmbeddingResult, ImageResult, ReconstructionResult, RetopologyResult, SegmentationResult,
    TextureResult, ThreeDResult, TranscriptionResult, VideoResult, VoiceHandle,
};
use crate::error::BlazenError;

// ---------------------------------------------------------------------------
// Core compute trait
// ---------------------------------------------------------------------------

/// A compute platform that supports async job submission and polling.
///
/// This is the base trait for compute providers like fal.ai, Replicate,
/// `RunPod`, etc. It models the common pattern of: submit a job, poll for
/// status, retrieve the result.
#[async_trait]
pub trait ComputeProvider: Send + Sync {
    /// Provider identifier (e.g., "fal", "replicate", "runpod").
    fn provider_id(&self) -> &str;

    /// Submit a compute job and get a handle to track it.
    async fn submit(&self, request: ComputeRequest) -> Result<JobHandle, BlazenError>;

    /// Poll the current status of a submitted job.
    async fn status(&self, job: &JobHandle) -> Result<JobStatus, BlazenError>;

    /// Wait for a job to complete and return the result.
    ///
    /// The default implementation delegates to the provider. Providers may
    /// override this with long-polling, `WebSockets`, or SSE.
    async fn result(&self, job: JobHandle) -> Result<ComputeResult, BlazenError>;

    /// Cancel a running or queued job.
    async fn cancel(&self, job: &JobHandle) -> Result<(), BlazenError>;

    /// Submit a job and wait for the result (convenience method).
    ///
    /// This is equivalent to calling [`ComputeProvider::submit`] followed
    /// by [`ComputeProvider::result`].
    async fn run(&self, request: ComputeRequest) -> Result<ComputeResult, BlazenError> {
        let job = self.submit(request).await?;
        self.result(job).await
    }

    /// Optional configuration metadata for this provider.
    fn provider_config(&self) -> Option<&crate::traits::ProviderConfig> {
        None
    }
}

// Arc passthrough for the base compute trait so capability sub-traits
// (e.g. `VideoEdit`) can also be forwarded through `Arc<P>` — their
// `impl ... for Arc<P>` requires `Arc<P>: ComputeProvider`.
#[async_trait]
impl<P: ComputeProvider + ?Sized> ComputeProvider for Arc<P> {
    fn provider_id(&self) -> &str {
        (**self).provider_id()
    }
    async fn submit(&self, request: ComputeRequest) -> Result<JobHandle, BlazenError> {
        (**self).submit(request).await
    }
    async fn status(&self, job: &JobHandle) -> Result<JobStatus, BlazenError> {
        (**self).status(job).await
    }
    async fn result(&self, job: JobHandle) -> Result<ComputeResult, BlazenError> {
        (**self).result(job).await
    }
    async fn cancel(&self, job: &JobHandle) -> Result<(), BlazenError> {
        (**self).cancel(job).await
    }
    async fn run(&self, request: ComputeRequest) -> Result<ComputeResult, BlazenError> {
        (**self).run(request).await
    }
    fn provider_config(&self) -> Option<&crate::traits::ProviderConfig> {
        (**self).provider_config()
    }
}

// ---------------------------------------------------------------------------
// Media-specific traits
// ---------------------------------------------------------------------------

/// Image generation and upscaling capability.
///
/// Providers that support image generation (fal.ai, Replicate, etc.)
/// implement this trait to provide a typed interface for image operations.
#[async_trait]
pub trait ImageGeneration: ComputeProvider {
    /// Generate images from a text prompt.
    async fn generate_image(&self, request: ImageRequest) -> Result<ImageResult, BlazenError>;

    /// Upscale an existing image.
    async fn upscale_image(&self, request: UpscaleRequest) -> Result<ImageResult, BlazenError>;

    /// Edit an existing image (img2img, inpaint, outpaint, etc.).
    ///
    /// Returns [`BlazenError::Unsupported`] by default so existing image
    /// providers keep compiling unchanged; providers that support editing
    /// (fal.ai, etc.) override this.
    async fn edit_image(&self, _request: ImageEditRequest) -> Result<ImageResult, BlazenError> {
        Err(BlazenError::unsupported(
            "image editing not supported by this provider",
        ))
    }
}

/// Video generation capability.
///
/// Providers that support video synthesis implement this trait.
#[async_trait]
pub trait VideoGeneration: ComputeProvider {
    /// Generate a video from a text prompt.
    async fn text_to_video(&self, request: VideoRequest) -> Result<VideoResult, BlazenError>;

    /// Generate a video from a source image and prompt.
    async fn image_to_video(&self, request: VideoRequest) -> Result<VideoResult, BlazenError>;
}

/// Video editing / conditioning capability (VACE-style: reference / control /
/// inpaint / outpaint / extend → video). Beyond plain text→video.
#[async_trait]
pub trait VideoEdit: ComputeProvider {
    /// Edit/condition a video from references, a control video, and/or a mask.
    ///
    /// Returns [`BlazenError::Unsupported`] by default so existing video
    /// providers keep compiling unchanged; providers that support editing
    /// (native VACE, fal, etc.) override this.
    async fn edit_video(&self, _request: VideoEditRequest) -> Result<VideoResult, BlazenError> {
        Err(BlazenError::unsupported(
            "video editing not supported by this provider",
        ))
    }
}

/// Audio generation capability (TTS, music, sound effects).
///
/// Providers that support audio synthesis implement this trait.
#[async_trait]
pub trait AudioGeneration: ComputeProvider {
    /// Synthesize speech from text.
    async fn text_to_speech(&self, request: SpeechRequest) -> Result<AudioResult, BlazenError>;

    /// Generate music from a prompt.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn generate_music(&self, _request: MusicRequest) -> Result<AudioResult, BlazenError> {
        Err(BlazenError::unsupported(
            "music generation not supported by this provider",
        ))
    }

    /// Generate sound effects from a prompt.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn generate_sfx(&self, _request: MusicRequest) -> Result<AudioResult, BlazenError> {
        Err(BlazenError::unsupported(
            "sound effect generation not supported by this provider",
        ))
    }
}

/// Audio transcription capability (speech-to-text).
///
/// Providers that support transcription implement this trait.
#[async_trait]
pub trait Transcription: ComputeProvider {
    /// Transcribe audio to text with optional diarization.
    async fn transcribe(
        &self,
        request: TranscriptionRequest,
    ) -> Result<TranscriptionResult, BlazenError>;
}

/// 3D model generation capability.
///
/// Providers that support 3D generation implement this trait.
#[async_trait]
pub trait ThreeDGeneration: ComputeProvider {
    /// Generate a 3D model from a text prompt or source image.
    async fn generate_3d(&self, request: ThreeDRequest) -> Result<ThreeDResult, BlazenError>;
}

/// Neural audio codec capability (PCM ↔ discrete tokens).
///
/// Providers that wrap a neural audio codec (`EnCodec`, `DAC`, `SNAC`, …)
/// implement this trait to expose deterministic encode / decode passes
/// outside the generative job API.
///
/// Both methods default to [`BlazenError::Unsupported`] so existing
/// non-codec providers do not need to override them.
#[async_trait]
pub trait Codec: ComputeProvider {
    /// Encode mono PCM samples (`f32` in `[-1.0, 1.0]`) into discrete
    /// codebook tokens.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn encode_audio(&self, _pcm: &[f32], _sample_rate: u32) -> Result<Vec<u32>, BlazenError> {
        Err(BlazenError::unsupported(
            "audio codec encode_audio not supported by this provider",
        ))
    }

    /// Decode flat row-major codebook tokens back into mono PCM samples.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn decode_audio(
        &self,
        _tokens: &[u32],
        _num_codebooks: usize,
    ) -> Result<Vec<f32>, BlazenError> {
        Err(BlazenError::unsupported(
            "audio codec decode_audio not supported by this provider",
        ))
    }
}

/// A compute provider that supports background removal on existing images.
#[async_trait]
pub trait BackgroundRemoval: ComputeProvider {
    /// Remove the background from an image and return the result.
    async fn remove_background(
        &self,
        request: BackgroundRemovalRequest,
    ) -> Result<ImageResult, BlazenError>;
}

/// Image-analysis capability: segmentation, depth estimation, and captioning.
///
/// This is the public seam for image-understanding models. Blazen ships the
/// fal proxy implementation; private native depth / segmentation / caption
/// models (in the zreg-only tier) implement this same trait so they can be
/// injected behind the public interface.
///
/// All three methods default to [`BlazenError::Unsupported`] so providers
/// opt in only to the capabilities they actually offer.
#[async_trait]
pub trait ImageAnalysis: ComputeProvider {
    /// Segment an image into one or more masks (automatic or promptable).
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn segment_image(
        &self,
        _request: SegmentationRequest,
    ) -> Result<SegmentationResult, BlazenError> {
        Err(BlazenError::unsupported(
            "image segmentation not supported by this provider",
        ))
    }

    /// Estimate a depth map from a single image.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn estimate_depth(&self, _request: DepthRequest) -> Result<DepthResult, BlazenError> {
        Err(BlazenError::unsupported(
            "depth estimation not supported by this provider",
        ))
    }

    /// Caption an image, or answer a question about it (VQA).
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn caption_image(&self, _request: CaptionRequest) -> Result<CaptionResult, BlazenError> {
        Err(BlazenError::unsupported(
            "image captioning not supported by this provider",
        ))
    }
}

/// Open-vocabulary object-detection capability: image + class prompts → boxes.
///
/// This is the public seam for open-vocabulary detectors (Grounding-DINO,
/// YOLO-World, OWL-ViT, …). Blazen ships fal-proxied detection; private native
/// detectors (in the zreg-only tier) implement this same trait so they can be
/// injected behind the public interface, exactly like [`ImageAnalysis`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers detection.
#[async_trait]
pub trait ObjectDetection: ComputeProvider {
    /// Detect objects in an image, constrained to the request's open-vocabulary
    /// class prompts (`text_prompt` and/or `classes`).
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn detect_objects(
        &self,
        _request: DetectionRequest,
    ) -> Result<DetectionResult, BlazenError> {
        Err(BlazenError::unsupported(
            "object detection not supported by this provider",
        ))
    }
}

/// Multi-view 3D reconstruction capability: N images / video → mesh + cloud.
///
/// This is the public seam for MASt3R-class reconstructors that recover scene
/// geometry and camera poses from multiple overlapping views. Blazen ships no
/// reconstruction backend today (fal has no `MASt3R` endpoint); private native
/// reconstructors (in the zreg-only tier) implement this same trait so they can
/// be injected behind the public interface, exactly like [`ObjectDetection`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers reconstruction.
#[async_trait]
pub trait Reconstruction: ComputeProvider {
    /// Reconstruct 3D geometry (mesh + optional point cloud + camera poses)
    /// from the request's multiple views (`image_urls` and/or `video_url`).
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn reconstruct(
        &self,
        _request: ReconstructionRequest,
    ) -> Result<ReconstructionResult, BlazenError> {
        Err(BlazenError::unsupported(
            "3D reconstruction not supported by this provider",
        ))
    }
}

/// Text-to-CAD capability: natural-language instruction → CAD script → mesh.
///
/// This is the public seam for instruction-driven CAD code generators
/// (BlenderLLM-class): an LLM emits an executable CAD program (e.g. Blender
/// `bpy`) from a textual part description, which is then run headless to
/// produce a mesh. The result carries **both** the generated mesh and the
/// script source. Blazen ships no CAD backend today; private native CAD models
/// (in the zreg-only tier) implement this same trait so they can be injected
/// behind the public interface, exactly like [`Reconstruction`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers CAD generation.
#[async_trait]
pub trait TextToCad: ComputeProvider {
    /// Generate a CAD model (mesh + the script that produced it) from the
    /// request's natural-language `instruction`.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn generate_cad(&self, _request: CadRequest) -> Result<CadResult, BlazenError> {
        Err(BlazenError::unsupported(
            "text-to-CAD generation not supported by this provider",
        ))
    }
}

/// Retopology capability: dense/scanned mesh → clean quad-dominant mesh.
///
/// This is the public seam for automatic retopology backends (`QuadriFlow` /
/// `QuadGPT` / Quad-Remesher-class) that rebuild a (typically triangulated or
/// scanned) mesh as an even-density, quad-dominant surface fit for
/// animation/subdivision. Blazen ships no retopology backend today; private
/// native retopologizers (in the zreg-only tier) implement this same trait so
/// they can be injected behind the public interface, exactly like
/// [`Reconstruction`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers retopology.
#[async_trait]
pub trait Retopology: ComputeProvider {
    /// Retopologize the request's `mesh_url` into a clean, quad-dominant mesh.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn retopologize(
        &self,
        _request: RetopologyRequest,
    ) -> Result<RetopologyResult, BlazenError> {
        Err(BlazenError::unsupported(
            "retopology not supported by this provider",
        ))
    }
}

/// CAD-reconstruction capability: point cloud → parametric CAD model + program.
///
/// This is the public seam for point-cloud-to-CAD reverse-engineering backends
/// (`CAD-Recode`-class): given a sampled point cloud, a model recovers an
/// editable parametric model plus the CAD program (e.g. a `CadQuery` Python
/// script) that constructs it. It is the point-cloud sibling of [`TextToCad`]'s
/// instruction→CAD seam, and the result carries **both** the model and the
/// script source. Blazen ships no CAD-reconstruction backend today; private
/// native models (in the zreg-only tier) implement this same trait so they can
/// be injected behind the public interface, exactly like [`Reconstruction`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers CAD reconstruction.
#[async_trait]
pub trait CadReconstruction: ComputeProvider {
    /// Reconstruct a parametric CAD model (model + the program that produced
    /// it) from the request's `point_cloud_url`.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn reconstruct_cad(
        &self,
        _request: CadReconstructionRequest,
    ) -> Result<CadReconstructionResult, BlazenError> {
        Err(BlazenError::unsupported(
            "CAD reconstruction not supported by this provider",
        ))
    }
}

/// Mesh-texturing capability: mesh + prompt → PBR texture set.
///
/// This is the public seam for text-conditioned mesh texturers (`Paint3D` /
/// `TEXTure` / `MVDream`-class) that paint a physically-based material set onto an
/// existing mesh. Blazen ships no texturing backend today; private native
/// texturers (in the zreg-only tier) implement this same trait so they can be
/// injected behind the public interface, exactly like [`Reconstruction`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers texturing.
///
/// # Why there is no `FalProvider` implementation (abstraction-only)
///
/// Unlike the other compute traits, `TextureGeneration` ships **no fal proxy**:
///
/// - **Native is blocked.** A native texturer needs ControlNet-style residual
///   injection into the candle `UNet` (still missing — candle's `UNet` has no
///   residual-injection seam) *and* a differentiable mesh rasteriser to bake
///   the multi-view paint back onto UV space (no candle equivalent). Both gaps
///   are tracked in the private `blazen-models-3d` tier.
/// - **No fal endpoint fits.** As of 2026-06 fal.ai exposes *no* mesh-texturing
///   endpoint. Every fal 3D app (`hunyuan3d/v2`, `trellis`, `hyper3d/rodin`,
///   `triposr`) takes **text or an image** and emits a *new* mesh — the mesh is
///   the output, never the input — so the texture set is baked during
///   generation and there is no `(mesh + prompt) -> textures` API to proxy.
///   The only mesh-in endpoint, `triposr/remeshing`, only re-topologises
///   geometry and produces no textures. Forcing a [`TextureRequest::mesh_url`]
///   into an `image_url` field would be semantically wrong (a mesh is not an
///   image), so no proxy is wired.
///
/// `TextureGeneration` therefore stays **abstraction-only**: the public seam
/// exists so a private native texturer (or a future fal texturing endpoint) can
/// be injected behind it, but every shipped provider inherits the default
/// `Unsupported` body until then.
#[async_trait]
pub trait TextureGeneration: ComputeProvider {
    /// Paint a PBR texture set (albedo + optional normal/roughness/metallic)
    /// onto the request's `mesh_url`, guided by the request's `prompt`.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn generate_texture(
        &self,
        _request: TextureRequest,
    ) -> Result<TextureResult, BlazenError> {
        Err(BlazenError::unsupported(
            "texture generation not supported by this provider",
        ))
    }
}

/// Multimodal embedding capability: image / text / audio → vector.
///
/// This is the public seam for multimodal embedders (CLIP / `SigLIP` / CLAP /
/// sentence-transformer-class) that encode an input into a dense vector in a
/// shared embedding space. Blazen ships no embedding backend today; private
/// native embedders (in the zreg-only tier) implement this same trait so they
/// can be injected behind the public interface, exactly like [`Reconstruction`].
///
/// The single method defaults to [`BlazenError::Unsupported`] so a provider
/// opts in only when it actually offers embedding.
#[async_trait]
pub trait Embedding: ComputeProvider {
    /// Embed the request's `input` (text, image URL, or audio URL) into a
    /// dense vector.
    ///
    /// Returns [`BlazenError::Unsupported`] by default.
    async fn embed(&self, _request: EmbeddingRequest) -> Result<EmbeddingResult, BlazenError> {
        Err(BlazenError::unsupported(
            "embedding not supported by this provider",
        ))
    }
}

// ---------------------------------------------------------------------------
// Voice cloning
// ---------------------------------------------------------------------------

/// Voice cloning capability.
///
/// Distinct from `AudioGeneration::text_to_speech` because cloning creates
/// a persisted voice that can be reused across later TTS calls. No
/// Blazen-shipped provider implements this trait -- it exists so users
/// building their own providers (via `CustomProvider`) can wire up
/// services like `ElevenLabs` or `zvoice` into Blazen's capability system.
#[async_trait]
pub trait VoiceCloning: ComputeProvider {
    /// Clone a voice from one or more reference audio clips and return
    /// a persistent handle that can be passed as `SpeechRequest.voice`
    /// on subsequent TTS calls.
    async fn clone_voice(&self, request: VoiceCloneRequest) -> Result<VoiceHandle, BlazenError>;

    /// List all voices known to this provider (presets + cloned).
    ///
    /// Returns `BlazenError::Unsupported` by default.
    async fn list_voices(&self) -> Result<Vec<VoiceHandle>, BlazenError> {
        Err(BlazenError::unsupported(
            "list_voices not supported by this provider",
        ))
    }

    /// Delete a previously cloned voice.
    ///
    /// Returns `BlazenError::Unsupported` by default.
    async fn delete_voice(&self, voice: &VoiceHandle) -> Result<(), BlazenError> {
        let _ = voice;
        Err(BlazenError::unsupported(
            "delete_voice not supported by this provider",
        ))
    }
}

// Backwards-compatible type alias for the old trait name.
/// Alias for [`ImageGeneration`] -- the old name before the multi-modal
/// expansion.
pub trait ImageModel: ImageGeneration {}
impl<T: ImageGeneration> ImageModel for T {}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::super::requests::{ImageEditRequest, ImageEditType};
    use super::*;

    /// A minimal non-fal [`ImageGeneration`] provider that implements only the
    /// required methods and inherits the defaulted `edit_image`.
    struct NoEditProvider;

    #[async_trait]
    impl ComputeProvider for NoEditProvider {
        fn provider_id(&self) -> &'static str {
            "no-edit"
        }
        async fn submit(&self, _request: ComputeRequest) -> Result<JobHandle, BlazenError> {
            Err(BlazenError::unsupported("submit"))
        }
        async fn status(&self, _job: &JobHandle) -> Result<JobStatus, BlazenError> {
            Err(BlazenError::unsupported("status"))
        }
        async fn result(&self, _job: JobHandle) -> Result<ComputeResult, BlazenError> {
            Err(BlazenError::unsupported("result"))
        }
        async fn cancel(&self, _job: &JobHandle) -> Result<(), BlazenError> {
            Err(BlazenError::unsupported("cancel"))
        }
    }

    #[async_trait]
    impl ImageGeneration for NoEditProvider {
        async fn generate_image(&self, _request: ImageRequest) -> Result<ImageResult, BlazenError> {
            Err(BlazenError::unsupported("generate"))
        }
        async fn upscale_image(
            &self,
            _request: UpscaleRequest,
        ) -> Result<ImageResult, BlazenError> {
            Err(BlazenError::unsupported("upscale"))
        }
        // `edit_image` intentionally NOT overridden -> uses the trait default.
    }

    #[tokio::test]
    async fn default_edit_image_returns_unsupported() {
        let provider = NoEditProvider;
        let request = ImageEditRequest::new(
            "https://example.com/src.png",
            "make it pop",
            ImageEditType::Img2Img,
        );
        let err = provider.edit_image(request).await.unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    /// A provider that opts into [`ImageAnalysis`] but overrides none of its
    /// methods, so all three inherit the defaulted `Unsupported` bodies.
    struct NoAnalysisProvider;

    #[async_trait]
    impl ComputeProvider for NoAnalysisProvider {
        fn provider_id(&self) -> &'static str {
            "no-analysis"
        }
        async fn submit(&self, _request: ComputeRequest) -> Result<JobHandle, BlazenError> {
            Err(BlazenError::unsupported("submit"))
        }
        async fn status(&self, _job: &JobHandle) -> Result<JobStatus, BlazenError> {
            Err(BlazenError::unsupported("status"))
        }
        async fn result(&self, _job: JobHandle) -> Result<ComputeResult, BlazenError> {
            Err(BlazenError::unsupported("result"))
        }
        async fn cancel(&self, _job: &JobHandle) -> Result<(), BlazenError> {
            Err(BlazenError::unsupported("cancel"))
        }
    }

    // Opts into the capability without overriding any method.
    impl ImageAnalysis for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_image_analysis_methods_return_unsupported() {
        let provider = NoAnalysisProvider;

        let seg_err = provider
            .segment_image(SegmentationRequest::new("https://example.com/img.png"))
            .await
            .unwrap_err();
        assert!(
            matches!(seg_err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {seg_err:?}"
        );

        let depth_err = provider
            .estimate_depth(DepthRequest::new("https://example.com/img.png"))
            .await
            .unwrap_err();
        assert!(
            matches!(depth_err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {depth_err:?}"
        );

        let cap_err = provider
            .caption_image(CaptionRequest::new("https://example.com/img.png"))
            .await
            .unwrap_err();
        assert!(
            matches!(cap_err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {cap_err:?}"
        );
    }

    // Opts into detection without overriding the method -> defaulted body.
    impl ObjectDetection for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_detect_objects_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .detect_objects(
                DetectionRequest::new("https://example.com/img.png").with_prompt("a dog. a cat."),
            )
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    // Opts into reconstruction without overriding the method -> defaulted body.
    impl Reconstruction for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_reconstruct_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .reconstruct(ReconstructionRequest::from_images([
                "https://example.com/view1.png",
                "https://example.com/view2.png",
            ]))
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    // Opts into text-to-CAD without overriding the method -> defaulted body.
    impl TextToCad for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_generate_cad_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .generate_cad(CadRequest::new("a hexagonal nut with a central hole"))
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    // Opts into retopology without overriding the method -> defaulted body.
    impl Retopology for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_retopologize_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .retopologize(RetopologyRequest::from_mesh(
                "https://example.com/dense.glb",
            ))
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    // Opts into CAD reconstruction without overriding the method -> defaulted body.
    impl CadReconstruction for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_reconstruct_cad_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .reconstruct_cad(CadReconstructionRequest::from_point_cloud(
                "https://example.com/scan.ply",
            ))
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    // Opts into texture generation without overriding the method -> defaulted body.
    impl TextureGeneration for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_generate_texture_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .generate_texture(TextureRequest::from_mesh_and_prompt(
                "https://example.com/mesh.glb",
                "weathered bronze",
            ))
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }

    // Opts into embedding without overriding the method -> defaulted body.
    impl Embedding for NoAnalysisProvider {}

    #[tokio::test]
    async fn default_embed_returns_unsupported() {
        let provider = NoAnalysisProvider;
        let err = provider
            .embed(EmbeddingRequest::from_text("a photo of a dragon"))
            .await
            .unwrap_err();
        assert!(
            matches!(err, BlazenError::Unsupported { .. }),
            "expected Unsupported, got: {err:?}"
        );
    }
}