Skip to main content

ml_runtime_common/
lib.rs

1use futures_core::Stream;
2use std::pin::Pin;
3use thiserror::Error;
4
5pub use tokio_util::sync::CancellationToken;
6
7pub type RuntimeResult<T> = Result<T, RuntimeError>;
8pub type BoxStream<T> = Pin<Box<dyn Stream<Item = T> + Send>>;
9
10/// Stable, structured failures returned by the public runtime API.
11#[derive(Clone, Debug, Error, PartialEq, Eq)]
12pub enum RuntimeError {
13    #[error("invalid request: {reason}")]
14    InvalidRequest { reason: String },
15    #[error("model not found: {model}")]
16    ModelNotFound { model: String },
17    #[error("model unavailable: {model} from {provider}: {reason}")]
18    ModelUnavailable {
19        model: String,
20        provider: String,
21        reason: String,
22    },
23    #[error("model integrity failure for {model}: {reason}")]
24    ModelIntegrity { model: String, reason: String },
25    #[error("unsupported model {model} for backend {backend}: {reason}")]
26    UnsupportedModel {
27        model: String,
28        backend: String,
29        reason: String,
30    },
31    #[error("backend unavailable: {backend}{reason}")]
32    BackendUnavailable { backend: String, reason: String },
33    #[error("provider unavailable: {provider}{reason}")]
34    ProviderUnavailable { provider: String, reason: String },
35    #[error("invalid input: {reason}")]
36    InvalidInput { reason: String },
37    #[error("unsupported input: {reason}")]
38    UnsupportedInput { reason: String },
39    #[error("invalid output: {reason}")]
40    InvalidOutput { reason: String },
41    #[error("capability mismatch: {reason}")]
42    CapabilityMismatch { reason: String },
43    #[error("resource limit exceeded: {reason}")]
44    ResourceLimit { reason: String },
45    #[error("timeout while {operation}")]
46    Timeout { operation: String },
47    #[error("operation cancelled")]
48    Cancelled,
49    #[error("transport error from {provider}: {reason}")]
50    Transport { provider: String, reason: String },
51    #[error("protocol error while {operation}: {reason}")]
52    Protocol { operation: String, reason: String },
53    #[error("execution error in {operation}: {reason}")]
54    Execution { operation: String, reason: String },
55}
56
57impl RuntimeError {
58    pub fn backend_unavailable(backend: impl Into<String>, reason: impl Into<String>) -> Self {
59        let reason = reason.into();
60        Self::BackendUnavailable {
61            backend: backend.into(),
62            reason: if reason.is_empty() {
63                String::new()
64            } else {
65                format!(": {reason}")
66            },
67        }
68    }
69
70    pub fn provider_unavailable(provider: impl Into<String>, reason: impl Into<String>) -> Self {
71        let reason = reason.into();
72        Self::ProviderUnavailable {
73            provider: provider.into(),
74            reason: if reason.is_empty() {
75                String::new()
76            } else {
77                format!(": {reason}")
78            },
79        }
80    }
81
82    pub fn transport(provider: impl Into<String>, reason: impl Into<String>) -> Self {
83        Self::Transport {
84            provider: provider.into(),
85            reason: reason.into(),
86        }
87    }
88
89    pub fn execution(operation: impl Into<String>, reason: impl Into<String>) -> Self {
90        Self::Execution {
91            operation: operation.into(),
92            reason: reason.into(),
93        }
94    }
95}