Skip to main content

jev/
provider.rs

1//! Hosted providers and their endpoint conventions.
2
3use std::{borrow::Cow, fmt, str::FromStr};
4
5use serde::{Deserialize, Serialize};
6
7use crate::{config::Surface, error::Error, model::Model};
8
9/// The hosted service that receives requests and authenticates the API key.
10///
11/// `OpenRouter` supports both API surfaces. `TypeSafe` always uses System One,
12/// including when a configuration leaves the surface at its default.
13///
14/// # Examples
15///
16/// ```
17/// use jev::Provider;
18///
19/// assert_eq!(Provider::default(), Provider::OpenRouter);
20/// assert_eq!("typesafe".parse::<Provider>()?, Provider::TypeSafe);
21/// # Ok::<(), jev::Error>(())
22/// ```
23#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
24#[serde(rename_all = "camelCase")]
25#[non_exhaustive]
26pub enum Provider {
27    /// `OpenRouter`, authenticated with an `OpenRouter` API key.
28    #[default]
29    #[serde(rename = "openrouter", alias = "openRouter")]
30    OpenRouter,
31    /// `TypeSafe` AI's direct API, authenticated with a `TypeSafe` API key.
32    #[serde(rename = "typesafe", alias = "typeSafe", alias = "typesafeai")]
33    TypeSafe,
34}
35
36impl Provider {
37    pub(crate) fn api_base(self) -> &'static str {
38        match self {
39            Self::OpenRouter => "https://openrouter.ai",
40            Self::TypeSafe => "https://api.typesafe.ai",
41        }
42    }
43
44    pub(crate) fn surface(self, requested: Surface) -> Surface {
45        match self {
46            Self::OpenRouter => requested,
47            Self::TypeSafe => Surface::SystemOne,
48        }
49    }
50
51    pub(crate) fn path(self, requested: Surface) -> &'static str {
52        match self {
53            Self::OpenRouter => requested.path(),
54            Self::TypeSafe => "/v1/systemone",
55        }
56    }
57
58    pub(crate) fn api_key_env(self) -> &'static str {
59        match self {
60            Self::OpenRouter => "OPENROUTER_API_KEY",
61            Self::TypeSafe => "TYPESAFE_API_KEY",
62        }
63    }
64
65    pub(crate) fn wire_id(self, model: &Model, requested: Surface) -> Cow<'_, str> {
66        match (self, model) {
67            (Self::TypeSafe, Model::Jev113) => Cow::Borrowed("jev-1.13.0"),
68            _ => model.wire_id(self.surface(requested)),
69        }
70    }
71}
72
73impl fmt::Display for Provider {
74    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
75        f.write_str(match self {
76            Self::OpenRouter => "openrouter",
77            Self::TypeSafe => "typesafe",
78        })
79    }
80}
81
82impl FromStr for Provider {
83    type Err = Error;
84
85    /// Parses a provider name used by `JEV_PROVIDER` or configuration.
86    ///
87    /// # Errors
88    ///
89    /// Returns [`Error::Invalid`] for an unknown provider name.
90    ///
91    /// # Examples
92    ///
93    /// ```
94    /// use jev::Provider;
95    ///
96    /// assert_eq!("openrouter".parse::<Provider>()?, Provider::OpenRouter);
97    /// assert_eq!("typesafeai".parse::<Provider>()?, Provider::TypeSafe);
98    /// # Ok::<(), jev::Error>(())
99    /// ```
100    fn from_str(value: &str) -> Result<Self, Self::Err> {
101        match value {
102            "openrouter" | "openRouter" => Ok(Self::OpenRouter),
103            "typesafe" | "typeSafe" | "typesafeai" => Ok(Self::TypeSafe),
104            _ => Err(Error::Invalid {
105                field: "provider".to_string(),
106                reason: "must be openrouter or typesafe".to_string(),
107            }),
108        }
109    }
110}
111
112#[cfg(test)]
113mod tests {
114    use rstest::rstest;
115
116    use super::*;
117
118    #[rstest]
119    #[case(Provider::OpenRouter)]
120    #[case(Provider::TypeSafe)]
121    fn test_should_round_trip_provider_names(#[case] provider: Provider) {
122        assert_eq!(provider.to_string().parse::<Provider>().unwrap(), provider);
123        let json = serde_json::to_string(&provider).unwrap();
124        assert_eq!(serde_json::from_str::<Provider>(&json).unwrap(), provider);
125    }
126
127    #[test]
128    fn test_should_reject_unknown_provider() {
129        assert!(matches!(
130            "other".parse::<Provider>(),
131            Err(Error::Invalid { .. })
132        ));
133        assert!(serde_json::from_str::<Provider>("\"other\"").is_err());
134    }
135}