1use std::borrow::Cow;
18use std::fmt;
19use std::hash::{Hash, Hasher};
20
21use serde::de;
22use serde::{Deserialize, Deserializer, Serialize, Serializer};
23
24use crate::catalog::{Catalog, ModelFacts, ModelSpec, NotFound, Reference};
25use crate::client::env::{self, EnvError};
26use crate::driver::DynModel;
27use crate::http_client::{DynHttpClient, HttpClientExt};
28use crate::operation::Completion;
29use crate::providers::{anthropic, gemini, openai};
30use crate::serve::ErasedHandler;
31use crate::serve::adapters::ModelAdapter;
32use crate::wire::Secret;
33
34pub(crate) const OPENAI_DIALECTS: &[&openai::wire::Dialect] = &[
41 &openai::wire::OPENAI,
42 &openai::wire::AZURE,
43 &openai::wire::DEEPSEEK,
44 &openai::wire::GROQ,
45 &openai::wire::HYPERBOLIC,
46 &openai::wire::MIRA,
47 &openai::wire::PERPLEXITY,
48 &openai::wire::TOGETHER,
49 &openai::wire::HUGGINGFACE,
50 &openai::wire::LLAMACPP,
51 &openai::wire::MISTRAL,
52 &openai::wire::OPENROUTER,
53 &openai::wire::VENICE,
54 &openai::wire::DOUBLEWORD,
55 &openai::wire::ZAI,
56 &openai::wire::MINIMAX,
57 &openai::wire::MOONSHOT,
58 &openai::wire::XIAOMIMIMO,
59 &openai::wire::COHERE,
60 &openai::wire::OLLAMA,
61 &openai::wire::OPENCODE,
62 &openai::wire::OPENCODE_GO,
63 &crate::providers::xai::DIALECT,
64 &crate::providers::chatgpt::DIALECT,
65 &crate::providers::copilot::wire::DIALECT,
66];
67
68#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
72#[serde(rename_all = "lowercase")]
73pub enum Format {
74 OpenAi,
76 Anthropic,
78 Gemini,
80}
81
82impl Format {
83 pub const ALL: [Format; 3] = [Format::OpenAi, Format::Anthropic, Format::Gemini];
85
86 pub fn as_str(self) -> &'static str {
88 match self {
89 Format::OpenAi => "openai",
90 Format::Anthropic => "anthropic",
91 Format::Gemini => "gemini",
92 }
93 }
94
95 pub fn named(name: &str) -> Option<Self> {
97 Self::ALL.into_iter().find(|format| format.as_str() == name)
98 }
99
100 fn names() -> String {
102 Self::ALL
103 .iter()
104 .map(|format| format.as_str())
105 .collect::<Vec<_>>()
106 .join(", ")
107 }
108}
109
110impl fmt::Display for Format {
111 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
112 f.write_str(self.as_str())
113 }
114}
115
116#[derive(Debug, Clone, Copy)]
118enum Registered {
119 OpenAi(openai::wire::Dialect),
120 Anthropic(anthropic::wire::Dialect),
121 Gemini,
122}
123
124impl Registered {
125 fn vendor(&self) -> &'static str {
126 match self {
127 Self::OpenAi(dialect) => dialect.name,
128 Self::Anthropic(dialect) => dialect.name,
129 Self::Gemini => gemini::PROVIDER_NAME,
130 }
131 }
132
133 fn format(&self) -> Format {
134 match self {
135 Self::OpenAi(_) => Format::OpenAi,
136 Self::Anthropic(_) => Format::Anthropic,
137 Self::Gemini => Format::Gemini,
138 }
139 }
140
141 fn config(&self, api_key: impl Into<Secret>) -> ProviderConfig {
142 match self {
143 Self::OpenAi(dialect) => {
144 ProviderConfig::OpenAi(openai::wire::OpenAIConfig::with_key(dialect, api_key))
145 }
146 Self::Anthropic(dialect) => ProviderConfig::Anthropic(
147 anthropic::wire::AnthropicConfig::with_key(dialect, api_key),
148 ),
149 Self::Gemini => ProviderConfig::Gemini(gemini::GeminiConfig::new(api_key)),
150 }
151 }
152
153 fn config_from_env(&self) -> Result<ProviderConfig, ConnectError> {
158 let tried = self.key_envs();
159 let (api_key, name) = key_from_env(self.vendor(), tried, self.requires_credential())?;
160 Ok(match self {
161 Self::OpenAi(dialect) => {
162 let auth = openai_auth(dialect, name);
163 ProviderConfig::OpenAi(openai::wire::OpenAIConfig::from_env_with_credential(
164 dialect, api_key, auth,
165 )?)
166 }
167 Self::Anthropic(dialect) => ProviderConfig::Anthropic(
168 anthropic::wire::AnthropicConfig::from_env_with_credential(dialect, api_key)?,
169 ),
170 Self::Gemini => ProviderConfig::Gemini(gemini::GeminiConfig::new(api_key)),
171 })
172 }
173
174 fn key_envs(&self) -> Vec<&'static str> {
176 match self {
177 Self::OpenAi(dialect) => openai_key_envs(dialect),
178 Self::Anthropic(dialect) => vec![dialect.api_key_env],
179 Self::Gemini => vec![gemini::API_KEY_ENV],
180 }
181 }
182
183 fn base_url_envs(&self) -> Vec<&'static str> {
186 let envs = match self {
187 Self::OpenAi(dialect) => [dialect.base_url_env, dialect.quirks.base_url_env_alias],
188 Self::Anthropic(dialect) => [dialect.base_url_env, None],
189 Self::Gemini => [None, None],
190 };
191 envs.into_iter().flatten().collect()
192 }
193
194 fn short_lived_key(&self) -> bool {
196 matches!(self, Self::OpenAi(dialect) if dialect.quirks.short_lived_key)
197 }
198
199 fn catalog_priced(&self) -> bool {
201 match self {
202 Self::OpenAi(dialect) => dialect.quirks.catalog_priced,
203 Self::Anthropic(dialect) => dialect.quirks.catalog_priced,
204 Self::Gemini => true,
205 }
206 }
207
208 fn requires_credential(&self) -> bool {
210 match self {
211 Self::OpenAi(dialect) => openai_requires_credential(dialect),
212 Self::Anthropic(dialect) => {
213 dialect.quirks.auth != anthropic::wire::Auth::OptionalBearer
214 }
215 Self::Gemini => true,
216 }
217 }
218}
219
220fn openai_key_envs(dialect: &openai::wire::Dialect) -> Vec<&'static str> {
223 std::iter::once(dialect.api_key_env)
224 .chain(
225 dialect
226 .alternate_auth
227 .map(|alternative| alternative.api_key_env),
228 )
229 .collect()
230}
231
232fn openai_requires_credential(dialect: &openai::wire::Dialect) -> bool {
235 !matches!(dialect.quirks.auth, openai::wire::Auth::OptionalBearer)
236}
237
238fn openai_auth(dialect: &openai::wire::Dialect, name: Option<&'static str>) -> openai::wire::Auth {
242 match dialect.alternate_auth {
243 Some(alternative) if name == Some(alternative.api_key_env) => alternative.auth,
244 _ => dialect.quirks.auth,
245 }
246}
247
248fn key_from_env(
252 vendor: &str,
253 tried: Vec<&'static str>,
254 required: bool,
255) -> Result<(String, Option<&'static str>), ConnectError> {
256 for name in &tried {
257 if let Some(value) = env::optional(name)?.filter(|value| !value.is_empty()) {
258 return Ok((value, Some(*name)));
259 }
260 }
261 if required {
262 return Err(ConnectError::MissingKey {
263 vendor: vendor.to_owned(),
264 tried: tried.into_iter().map(Cow::Borrowed).collect(),
265 });
266 }
267 Ok((String::new(), None))
268}
269
270#[derive(Debug)]
274struct CatalogOnly {
275 vendor: &'static str,
277 home: &'static str,
279 credential: bool,
281}
282
283static CATALOG_ONLY: [CatalogOnly; 5] = [
285 CatalogOnly {
286 vendor: "aws_bedrock",
287 home: "the `rig-bedrock` crate",
288 credential: true,
289 },
290 CatalogOnly {
291 vendor: "vertexai",
292 home: "the `rig-vertexai` crate",
293 credential: true,
294 },
295 CatalogOnly {
296 vendor: "gemini-grpc",
297 home: "the `rig-gemini-grpc` crate",
298 credential: true,
299 },
300 CatalogOnly {
301 vendor: "candle",
302 home: "the `rig-candle` crate",
303 credential: false,
304 },
305 CatalogOnly {
306 vendor: "voyageai",
307 home: "`rig_core::providers::voyageai`, which serves embeddings and reranking only",
308 credential: true,
309 },
310];
311
312#[derive(Debug, Clone, Copy)]
314enum Kind {
315 Registered(Registered),
317 CatalogOnly(&'static CatalogOnly),
319 Declared(&'static str),
321}
322
323static DECLARED: std::sync::RwLock<Vec<&'static str>> = std::sync::RwLock::new(Vec::new());
327
328fn declared(vendor: &str) -> Option<&'static str> {
330 DECLARED
331 .read()
332 .unwrap_or_else(std::sync::PoisonError::into_inner)
333 .iter()
334 .copied()
335 .find(|name| *name == vendor)
336}
337
338#[derive(Debug, Clone, Copy)]
347pub struct ProviderId(Kind);
348
349impl PartialEq for ProviderId {
352 fn eq(&self, other: &Self) -> bool {
353 self.vendor() == other.vendor() && self.format() == other.format()
354 }
355}
356
357impl Eq for ProviderId {}
358
359impl Hash for ProviderId {
360 fn hash<H: Hasher>(&self, state: &mut H) {
361 self.vendor().hash(state);
362 self.format().hash(state);
363 }
364}
365
366impl ProviderId {
367 pub fn all() -> impl Iterator<Item = ProviderId> {
371 openai::wire::all()
372 .map(|dialect| Registered::OpenAi(*dialect))
373 .chain(anthropic::wire::all().map(|dialect| Registered::Anthropic(*dialect)))
374 .chain(std::iter::once(Registered::Gemini))
375 .map(|registered| ProviderId(Kind::Registered(registered)))
376 }
377
378 pub fn new(vendor: &str, format: Format) -> Option<Self> {
381 let registered = match format {
382 Format::OpenAi => {
383 openai::wire::by_name(vendor).map(|dialect| Registered::OpenAi(*dialect))
384 }
385 Format::Anthropic => {
386 anthropic::wire::Dialect::by_name(vendor).map(Registered::Anthropic)
387 }
388 Format::Gemini => (vendor == gemini::PROVIDER_NAME).then_some(Registered::Gemini),
389 };
390 registered.map(|registered| Self(Kind::Registered(registered)))
391 }
392
393 pub fn catalog(vendor: &str) -> Option<Self> {
405 let primary = primary(vendor).and_then(|format| Self::new(vendor, format));
406 primary
407 .or_else(|| Self::vendor_selections(vendor).next())
408 .or_else(|| {
409 CATALOG_ONLY
410 .iter()
411 .find(|provider| provider.vendor == vendor)
412 .map(|provider| Self(Kind::CatalogOnly(provider)))
413 })
414 .or_else(|| declared(vendor).map(|name| Self(Kind::Declared(name))))
415 }
416
417 pub fn declare(vendor: &str) -> Result<Self, SelectionError> {
447 if vendor.is_empty() || vendor.contains('/') || vendor.contains(char::is_whitespace) {
448 return Err(SelectionError::Malformed {
449 selection: vendor.to_owned(),
450 });
451 }
452 if let Some(known) = Self::catalog(vendor) {
453 return Ok(known);
454 }
455 let mut names = DECLARED
456 .write()
457 .unwrap_or_else(std::sync::PoisonError::into_inner);
458 let name = match names.iter().copied().find(|name| *name == vendor) {
459 Some(name) => name,
460 None => {
461 let name: &'static str = Box::leak(vendor.to_owned().into_boxed_str());
462 names.push(name);
463 name
464 }
465 };
466 Ok(Self(Kind::Declared(name)))
467 }
468
469 pub(crate) fn catalog_vendors() -> impl Iterator<Item = &'static str> {
472 let declared: Vec<&'static str> = DECLARED
473 .read()
474 .unwrap_or_else(std::sync::PoisonError::into_inner)
475 .clone();
476 Self::all()
477 .map(|id| id.vendor())
478 .chain(CATALOG_ONLY.iter().map(|provider| provider.vendor))
479 .chain(declared)
480 }
481
482 pub fn vendor(&self) -> &'static str {
484 match &self.0 {
485 Kind::Registered(registered) => registered.vendor(),
486 Kind::CatalogOnly(provider) => provider.vendor,
487 Kind::Declared(vendor) => vendor,
488 }
489 }
490
491 pub fn format(&self) -> Option<Format> {
494 match &self.0 {
495 Kind::Registered(registered) => Some(registered.format()),
496 Kind::CatalogOnly(_) | Kind::Declared(_) => None,
497 }
498 }
499
500 pub fn is_registered(&self) -> bool {
504 matches!(self.0, Kind::Registered(_))
505 }
506
507 pub fn is_declared(&self) -> bool {
509 matches!(self.0, Kind::Declared(_))
510 }
511
512 pub fn vendor_selections(vendor: &str) -> impl Iterator<Item = ProviderId> + '_ {
514 Self::all().filter(move |id| id.vendor() == vendor)
515 }
516
517 pub fn resolve(selection: &str) -> Result<Self, SelectionError> {
524 let malformed = || SelectionError::Malformed {
525 selection: selection.to_owned(),
526 };
527 let (vendor, format) = match selection.split_once('/') {
528 Some((_, rest)) if rest.contains('/') => return Err(malformed()),
529 Some((vendor, format)) => (vendor, Some(format)),
530 None => (selection, None),
531 };
532 if vendor.is_empty() {
533 return Err(malformed());
534 }
535 let Some(format) = format else {
536 let mut registered = Self::vendor_selections(vendor);
537 let first = registered.next().ok_or_else(|| SelectionError::Unknown {
538 vendor: vendor.to_owned(),
539 })?;
540 return match registered.next() {
541 None => Ok(first),
542 Some(_) => Err(SelectionError::Ambiguous {
543 vendor: vendor.to_owned(),
544 alternatives: alternatives(vendor),
545 }),
546 };
547 };
548 let Some(family) = Format::named(format) else {
549 return Err(SelectionError::UnknownFormat {
550 format: format.to_owned(),
551 });
552 };
553 Self::selection(vendor, family)
554 }
555
556 pub fn config(&self, api_key: impl Into<Secret>) -> Option<ProviderConfig> {
560 match &self.0 {
561 Kind::Registered(registered) => Some(registered.config(api_key)),
562 Kind::CatalogOnly(_) | Kind::Declared(_) => None,
563 }
564 }
565
566 pub fn api_key_envs(&self) -> Vec<&'static str> {
572 match &self.0 {
573 Kind::Registered(registered) => registered.key_envs(),
574 Kind::CatalogOnly(_) | Kind::Declared(_) => Vec::new(),
575 }
576 }
577
578 pub fn requires_credential(&self) -> bool {
584 match &self.0 {
585 Kind::Registered(registered) => registered.requires_credential(),
586 Kind::CatalogOnly(provider) => provider.credential,
587 Kind::Declared(_) => false,
588 }
589 }
590
591 pub(crate) fn configured_in_env(&self) -> bool {
596 let Kind::Registered(registered) = &self.0 else {
597 return false;
598 };
599 let set = |name: &'static str| {
600 env::optional(name).is_ok_and(|value| value.is_some_and(|value| !value.is_empty()))
601 };
602 let mut envs = registered
603 .key_envs()
604 .into_iter()
605 .chain(registered.base_url_envs());
606 envs.any(set)
607 }
608
609 pub fn short_lived_key(&self) -> bool {
612 matches!(&self.0, Kind::Registered(registered) if registered.short_lived_key())
613 }
614
615 pub(crate) fn catalog_priced(&self) -> bool {
618 match &self.0 {
619 Kind::Registered(registered) => registered.catalog_priced(),
620 Kind::CatalogOnly(_) | Kind::Declared(_) => true,
621 }
622 }
623
624 fn registered(self) -> Result<Registered, ConnectError> {
626 match self.0 {
627 Kind::Registered(registered) => Ok(registered),
628 Kind::CatalogOnly(provider) => Err(ConnectError::CatalogOnly {
629 vendor: provider.vendor.to_owned(),
630 served_by: provider.home,
631 }),
632 Kind::Declared(vendor) => Err(ConnectError::CatalogOnly {
633 vendor: vendor.to_owned(),
634 served_by: "whoever declared it: provide it with `Connector::provide`",
635 }),
636 }
637 }
638
639 fn selection(vendor: &str, format: Format) -> Result<Self, SelectionError> {
641 Self::new(vendor, format).ok_or_else(|| {
642 let alternatives = alternatives(vendor);
643 match alternatives.is_empty() {
644 true => SelectionError::Unknown {
645 vendor: vendor.to_owned(),
646 },
647 false => SelectionError::Unregistered {
648 vendor: vendor.to_owned(),
649 format,
650 alternatives,
651 },
652 }
653 })
654 }
655}
656
657fn primary(vendor: &str) -> Option<Format> {
660 match vendor {
661 "minimax" => Some(Format::Anthropic),
662 "zai" | "moonshot" | "xiaomimimo" | "ollama" | "opencode" | "opencode-go" => {
663 Some(Format::OpenAi)
664 }
665 _ => None,
666 }
667}
668
669fn alternatives(vendor: &str) -> Vec<String> {
671 ProviderId::vendor_selections(vendor)
672 .map(|id| id.to_string())
673 .collect()
674}
675
676impl fmt::Display for ProviderId {
677 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
678 match self.format() {
679 Some(format) => write!(f, "{}/{format}", self.vendor()),
680 None => f.write_str(self.vendor()),
681 }
682 }
683}
684
685impl Serialize for ProviderId {
686 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
687 serializer.collect_str(self)
688 }
689}
690
691impl<'de> Deserialize<'de> for ProviderId {
695 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
696 let selection = String::deserialize(deserializer)?;
697 Self::resolve(&selection)
698 .or_else(|error| {
699 Self::catalog(&selection)
700 .filter(|id| !id.is_registered())
701 .ok_or(error)
702 })
703 .map_err(de::Error::custom)
704 }
705}
706
707#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
709pub enum SelectionError {
710 #[error("no registered provider is named `{vendor}`")]
712 Unknown {
713 vendor: String,
715 },
716 #[error(
718 "`{vendor}` speaks no {format} endpoint in this build (it speaks {})",
719 alternatives.join(", ")
720 )]
721 Unregistered {
722 vendor: String,
724 format: Format,
726 alternatives: Vec<String>,
728 },
729 #[error(
731 "`{vendor}` names more than one registered selection: name one of {}",
732 alternatives.join(", ")
733 )]
734 Ambiguous {
735 vendor: String,
737 alternatives: Vec<String>,
739 },
740 #[error("`{format}` is not a protocol family ({})", Format::names())]
742 UnknownFormat {
743 format: String,
745 },
746 #[error("`{selection}` is not a provider selection: expected `vendor` or `vendor/format`")]
748 Malformed {
749 selection: String,
751 },
752}
753
754#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
759#[serde(rename_all = "lowercase")]
760pub enum ProviderConfig {
761 OpenAi(openai::wire::OpenAIConfig),
763 Anthropic(anthropic::wire::AnthropicConfig),
765 Gemini(gemini::GeminiConfig),
767}
768
769impl ProviderConfig {
770 pub fn id(&self) -> Option<ProviderId> {
774 ProviderId::new(self.vendor(), self.format())
775 }
776
777 pub fn vendor(&self) -> &'static str {
779 match self {
780 Self::OpenAi(provider) => provider.dialect.name,
781 Self::Anthropic(provider) => provider.dialect.name,
782 Self::Gemini(_) => gemini::PROVIDER_NAME,
783 }
784 }
785
786 pub fn format(&self) -> Format {
788 match self {
789 Self::OpenAi(_) => Format::OpenAi,
790 Self::Anthropic(_) => Format::Anthropic,
791 Self::Gemini(_) => Format::Gemini,
792 }
793 }
794
795 pub fn is_unauthenticated(&self) -> bool {
798 match self {
799 Self::OpenAi(provider) => provider.api_key.is_empty(),
800 Self::Anthropic(provider) => provider.api_key.is_empty(),
801 Self::Gemini(provider) => provider.api_key.is_empty(),
802 }
803 }
804
805 pub fn with_credential(mut self, api_key: impl Into<Secret>) -> Self {
808 let api_key = api_key.into();
809 match &mut self {
810 Self::OpenAi(provider) => provider.api_key = api_key,
811 Self::Anthropic(provider) => provider.api_key = api_key,
812 Self::Gemini(provider) => provider.api_key = api_key,
813 }
814 self
815 }
816
817 pub fn base_url(&self) -> &str {
826 match self {
827 Self::OpenAi(provider) => &provider.base_url,
828 Self::Anthropic(provider) => &provider.base_url,
829 Self::Gemini(provider) => &provider.base_url,
830 }
831 }
832
833 pub fn with_base_url(self, base_url: impl Into<String>) -> Self {
837 let base_url = base_url.into();
838 match self {
839 Self::OpenAi(provider) => Self::OpenAi(provider.with_base_url(base_url)),
840 Self::Anthropic(provider) => Self::Anthropic(provider.with_base_url(base_url)),
841 Self::Gemini(provider) => Self::Gemini(provider.with_base_url(base_url)),
842 }
843 }
844
845 pub fn completion_handler(
849 &self,
850 label: &str,
851 model: &str,
852 http: DynHttpClient,
853 facts: ModelFacts,
854 ) -> ErasedHandler {
855 ErasedHandler::new(ModelAdapter::new(
856 label,
857 self.completion_model(model, http, facts),
858 ))
859 }
860
861 pub fn completion_model(
872 &self,
873 model: &str,
874 http: DynHttpClient,
875 facts: ModelFacts,
876 ) -> DynModel<Completion> {
877 match self {
878 Self::OpenAi(provider) => {
879 let wire = openai::wire::OpenAiWire::routed(provider.clone(), model, &facts)
880 .with_facts(facts);
881 provider.clone().connect(http).model(wire).erase()
882 }
883 Self::Anthropic(provider) => {
884 let mut model = provider.clone().connect(http).completion(model);
885 model.wire = model.wire.with_facts(facts);
886 model.erase()
887 }
888 Self::Gemini(provider) => {
889 let mut model = provider.clone().connect(http).completion(model);
890 model.wire = model.wire.with_facts(facts);
891 model.erase()
892 }
893 }
894 }
895}
896
897#[non_exhaustive]
900#[derive(Clone, Copy, Debug)]
901pub enum ModelSelector<'a> {
902 Spec(&'a ModelSpec),
904 Reference(&'a str),
906}
907
908impl<'a> From<&'a ModelSpec> for ModelSelector<'a> {
909 fn from(spec: &'a ModelSpec) -> Self {
910 Self::Spec(spec)
911 }
912}
913
914impl<'a> From<&'a str> for ModelSelector<'a> {
915 fn from(reference: &'a str) -> Self {
916 Self::Reference(reference)
917 }
918}
919
920impl<'a> From<&'a String> for ModelSelector<'a> {
921 fn from(reference: &'a String) -> Self {
922 Self::Reference(reference)
923 }
924}
925
926#[non_exhaustive]
941#[derive(Clone, Default)]
942pub struct ConnectOptions {
943 api_key: Option<Secret>,
944 account_id: Option<String>,
945 pub(crate) http: Option<DynHttpClient>,
946 format: Option<Format>,
947 base_url: Option<String>,
948}
949
950impl ConnectOptions {
951 pub fn new() -> Self {
953 Self::default()
954 }
955
956 pub fn api_key(mut self, api_key: impl Into<Secret>) -> Self {
959 self.api_key = Some(api_key.into());
960 self
961 }
962
963 pub fn account_id(mut self, account_id: impl Into<String>) -> Self {
976 self.account_id = Some(account_id.into());
977 self
978 }
979
980 pub fn http(mut self, http: impl HttpClientExt + 'static) -> Self {
982 self.http = Some(DynHttpClient::new(http));
983 self
984 }
985
986 pub fn format(mut self, format: Format) -> Self {
989 self.format = Some(format);
990 self
991 }
992
993 pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
995 self.base_url = Some(base_url.into());
996 self
997 }
998}
999
1000impl fmt::Debug for ConnectOptions {
1002 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1003 f.debug_struct("ConnectOptions")
1004 .field("api_key", &self.api_key.as_ref().map(|_| "<set>"))
1005 .field("account_id", &self.account_id.as_ref().map(|_| "<set>"))
1006 .field("http", &self.http.as_ref().map(|_| "<set>"))
1007 .field("format", &self.format)
1008 .field("base_url", &self.base_url)
1009 .finish()
1010 }
1011}
1012
1013#[non_exhaustive]
1015#[derive(Debug, thiserror::Error)]
1016pub enum ConnectError {
1017 #[error("`{reference}` names no model: expected `vendor/model`")]
1019 Malformed {
1020 reference: String,
1022 },
1023 #[error("the registry cannot connect to `{vendor}`: its models are served by {served_by}")]
1026 CatalogOnly {
1027 vendor: String,
1029 served_by: &'static str,
1031 },
1032 #[error(transparent)]
1035 NotFound(#[from] NotFound),
1036 #[error(transparent)]
1038 Selection(#[from] SelectionError),
1039 #[error(
1042 "no key for `{vendor}`: set {} or pass one with `ConnectOptions::api_key`",
1043 tried.iter().map(|name| format!("`{name}`")).collect::<Vec<_>>().join(" or ")
1044 )]
1045 MissingKey {
1046 vendor: String,
1048 tried: Vec<Cow<'static, str>>,
1051 },
1052 #[error("{0}")]
1055 Provider(String),
1056 #[error(transparent)]
1058 Env(#[from] EnvError),
1059 #[error("no HTTP client: pass one with `ConnectOptions::http`")]
1062 NoHttpClient,
1063}
1064
1065impl Catalog {
1066 #[cfg(feature = "reqwest")]
1080 #[cfg_attr(docsrs, doc(cfg(feature = "reqwest")))]
1081 pub fn connect<'a>(
1082 &self,
1083 model: impl Into<ModelSelector<'a>>,
1084 ) -> Result<DynModel<Completion>, ConnectError> {
1085 self.connect_with(model, ConnectOptions::new())
1086 }
1087
1088 pub fn connect_with<'a>(
1116 &self,
1117 model: impl Into<ModelSelector<'a>>,
1118 options: ConnectOptions,
1119 ) -> Result<DynModel<Completion>, ConnectError> {
1120 let (provider, model, facts) = match model.into() {
1121 ModelSelector::Spec(spec) => (
1122 spec.provider,
1123 spec.id.as_str(),
1124 ModelFacts::new(spec.clone()).with_catalog(self),
1125 ),
1126 ModelSelector::Reference(text) => {
1127 let reference = Reference::parse(text).ok_or_else(|| ConnectError::Malformed {
1128 reference: text.to_owned(),
1129 })?;
1130 let vendor =
1131 ProviderId::catalog(reference.vendor).ok_or_else(|| self.not_found(text))?;
1132 let provider = self
1133 .get_vendor(reference.vendor, reference.model)
1134 .map_or(vendor, |resolved| resolved.spec.provider);
1135 let provider = match reference.format {
1136 Some(format) if provider.is_registered() => {
1137 ProviderId::selection(reference.vendor, format)?
1138 }
1139 _ => provider,
1140 };
1141 (
1142 provider,
1143 reference.model,
1144 self.facts(provider, reference.model),
1145 )
1146 }
1147 };
1148 let provider = match options.format {
1149 Some(format) if provider.is_registered() => {
1150 ProviderId::selection(provider.vendor(), format)?
1151 }
1152 _ => provider,
1153 };
1154 let registered = provider.registered()?;
1155 let config = match options.api_key {
1156 Some(api_key) => registered.config(api_key),
1157 None => registered.config_from_env()?,
1158 };
1159 let config = match (config, options.account_id) {
1160 (ProviderConfig::OpenAi(provider), Some(account_id)) => {
1161 ProviderConfig::OpenAi(provider.with_account_id(account_id))
1162 }
1163 (config, _) => config,
1164 };
1165 let config = match options.base_url {
1166 Some(base_url) => config.with_base_url(base_url),
1167 None => config,
1168 };
1169 let http = match options.http {
1170 Some(http) => http,
1171 None => shared_http()?,
1172 };
1173 Ok(config.completion_model(model, http, facts))
1174 }
1175}
1176
1177#[cfg(feature = "reqwest")]
1179fn shared_http() -> Result<DynHttpClient, ConnectError> {
1180 Ok(rig_reqwest::shared())
1181}
1182
1183#[cfg(not(feature = "reqwest"))]
1185fn shared_http() -> Result<DynHttpClient, ConnectError> {
1186 Err(ConnectError::NoHttpClient)
1187}
1188
1189#[cfg(test)]
1190mod tests;