shimmy 1.9.0

Lightweight sub-5MB Ollama alternative with native SafeTensors support. No Python dependencies, 2x faster loading. Now with GitHub Spec-Kit integration for systematic development.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Vision Provider Adapter Trait
//!
//! Abstracts vision processing behind a trait so the implementation
//! can be swapped between:
//! - Private `shimmy-vision` crate (licensed users)
//! - Error stub (unlicensed/public users)

use crate::vision::{VisionRequest, VisionResponse};
#[allow(unused_imports)]
use crate::AppState;
#[allow(unused_imports)]
use std::future::Future;
#[allow(unused_imports)]
use std::pin::Pin;

/// Vision processing provider trait
pub trait VisionProvider: Send + Sync {
    /// Process a vision request
    #[allow(clippy::type_complexity)]
    fn process_vision_request<'a>(
        &'a self,
        req: VisionRequest,
        model_name: String,
        state: &'a crate::AppState,
    ) -> std::pin::Pin<
        Box<
            dyn std::future::Future<Output = Result<VisionResponse, Box<dyn std::error::Error>>>
                + Send
                + 'a,
        >,
    >;
}

/// Private vision provider (requires shimmy-vision crate)
#[cfg(feature = "vision")]
pub struct PrivateVisionProvider;

#[cfg(feature = "vision")]
impl VisionProvider for PrivateVisionProvider {
    fn process_vision_request<'a>(
        &'a self,
        req: VisionRequest,
        model_name: String,
        state: &'a crate::AppState,
    ) -> std::pin::Pin<
        Box<
            dyn std::future::Future<Output = Result<VisionResponse, Box<dyn std::error::Error>>>
                + Send
                + 'a,
        >,
    > {
        Box::pin(async move {
            // TODO: Call the private shimmy-vision crate for licensed vision processing
            // For now, call existing vision processing but skip license validation
            // since it will be handled by the private crate
            let license_manager = crate::vision_license::VisionLicenseManager::new();
            crate::vision::process_vision_request(req, &model_name, &license_manager, state).await
        })
    }
}

/// Stub vision provider (returns error for unlicensed users)
#[cfg(not(feature = "vision"))]
pub struct StubVisionProvider;

#[cfg(not(feature = "vision"))]
impl VisionProvider for StubVisionProvider {
    fn process_vision_request<'a>(
        &'a self,
        #[allow(unused_variables)] _req: VisionRequest,
        #[allow(unused_variables)] _model_name: String,
        #[allow(unused_variables)] _state: &'a crate::AppState,
    ) -> std::pin::Pin<
        Box<
            dyn std::future::Future<Output = Result<VisionResponse, Box<dyn std::error::Error>>>
                + Send
                + 'a,
        >,
    > {
        Box::pin(
            async move { Err("Vision feature not enabled. This is a licensed feature.".into()) },
        )
    }
}