sipp-rs 0.1.4

Unified Rust library for extensible Sipp inference
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::core::{CapabilitySupport, Operation};
use crate::engine::{ModelCapabilities, NativeRuntimeConfig};
use crate::lifecycle::ManagedModel;

use crate::client::GatewayDescriptor;
#[cfg(feature = "providers")]
use crate::client::ProviderDescriptor;

/////////////////////////////////////////////////////////////////////////////////
/// TESTS
/////////////////////////////////////////////////////////////////////////////////

#[cfg(test)]
#[path = "../tests/client/endpoint_tests.rs"]
mod endpoint_tests;

/////////////////////////////////////////////////////////////////////////////////
/// SRC
/////////////////////////////////////////////////////////////////////////////////

/// Configuration consumed by `SippClient::add` to register an endpoint.
#[derive(Debug, Clone, PartialEq)]
pub struct Endpoint {
    pub(super) kind: EndpointKind,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) enum EndpointKind {
    Local(Box<Local>),
    Gateway(Box<GatewayDescriptor>),
    #[cfg(feature = "providers")]
    Provider(Box<ProviderDescriptor>),
}

impl From<Local> for Endpoint {
    fn from(local: Local) -> Self {
        Self {
            kind: EndpointKind::Local(Box::new(local)),
        }
    }
}

impl From<GatewayDescriptor> for Endpoint {
    fn from(gateway: GatewayDescriptor) -> Self {
        Self {
            kind: EndpointKind::Gateway(Box::new(gateway)),
        }
    }
}

#[cfg(feature = "providers")]
impl From<ProviderDescriptor> for Endpoint {
    fn from(provider: ProviderDescriptor) -> Self {
        Self {
            kind: EndpointKind::Provider(Box::new(provider)),
        }
    }
}

/// Local endpoint input for a model managed by the client model store.
#[derive(Debug, Clone, PartialEq)]
pub struct Local {
    pub(super) model_id: String,
    pub(super) runtime: NativeRuntimeConfig,
}

impl Local {
    /// Create a local endpoint input using the canonical runtime configuration.
    pub fn new(model: &ManagedModel) -> Self {
        Self {
            model_id: model.id.clone(),
            runtime: NativeRuntimeConfig::default(),
        }
    }

    /// Set the native runtime configuration used when loading the model.
    #[must_use]
    pub fn runtime(mut self, runtime: NativeRuntimeConfig) -> Self {
        self.runtime = runtime;
        self
    }
}

/// Addressable inference destination.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct EndpointRef {
    id: String,
}

impl EndpointRef {
    /// Return the stable client-scoped endpoint id.
    pub fn id(&self) -> &str {
        &self.id
    }

    #[doc(hidden)]
    pub fn from_id(id: impl Into<String>) -> Self {
        Self { id: id.into() }
    }
}

/// Cached support for the public inference operations.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct EndpointCapabilities {
    /// Raw-prompt text generation support.
    pub query: CapabilitySupport,
    /// Chat generation support.
    pub chat: CapabilitySupport,
    /// Embedding support.
    pub embed: CapabilitySupport,
    /// Encoded-audio transcription support.
    pub listen: CapabilitySupport,
    /// Text-to-WAV synthesis support.
    pub speak: CapabilitySupport,
}

impl EndpointCapabilities {
    pub(crate) fn from_local(capabilities: &ModelCapabilities) -> Self {
        Self {
            query: support(capabilities.supports_operation(Operation::Query)),
            chat: support(capabilities.supports_operation(Operation::Chat)),
            embed: support(capabilities.supports_operation(Operation::Embed)),
            listen: support(capabilities.supports_operation(Operation::Listen)),
            speak: support(capabilities.supports_operation(Operation::Speak)),
        }
    }

    /// Return runtime-determined remote text capabilities with no speech support.
    pub const fn remote_text() -> Self {
        Self {
            query: CapabilitySupport::Unknown,
            chat: CapabilitySupport::Unknown,
            embed: CapabilitySupport::Unknown,
            listen: CapabilitySupport::Unsupported,
            speak: CapabilitySupport::Unsupported,
        }
    }

    /// Return support for one canonical inference operation.
    pub const fn for_operation(&self, operation: Operation) -> CapabilitySupport {
        match operation {
            Operation::Query => self.query,
            Operation::Chat => self.chat,
            Operation::Embed => self.embed,
            Operation::Listen => self.listen,
            Operation::Speak => self.speak,
        }
    }
}

const fn support(enabled: bool) -> CapabilitySupport {
    if enabled {
        CapabilitySupport::Supported
    } else {
        CapabilitySupport::Unsupported
    }
}