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#[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}