1. 1//! The closed set of voice providers and their static capability catalogue.
2. 2//!
3. 3//! A provider name is parsed exactly once, here. Every surface — the socket,
4. 4//! channel voice notes, `/voice/speak`, `/voice/providers`, doctor — resolves
5. 5//! through [`VoiceProvider`], so they cannot disagree about which names exist
6. 6//! or what an unset route means. Model and voice ids are never listed here:
7. 7//! they are properties of the operator's key (invariant 9).
8. 8
9. 9use crate::SpeakFormat;
10. 10use serde::Serialize;
11. 11use std::fmt;
12. 12use std::str::FromStr;
13. 13
14. 14#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
15. 15pub enum VoiceProvider {
16. 16 Gemini,
17. 17 OpenAi,
18. 18 Local,
19. 19}
20. 20
21. 21impl VoiceProvider {
22. 22 pub const ALL: [Self; 3] = [Self::Gemini, Self::OpenAi, Self::Local];
23. 23
24. 24 pub fn as_str(self) -> &'static str {
25. 25 match self {
26. 26 Self::Gemini => "gemini",
27. 27 Self::OpenAi => "openai",
28. 28 Self::Local => "local",
29. 29 }
30. 30 }
31. 31
32. 32 /// Credential variables consulted, in order, through the canonical
33. 33 /// secret chain. Empty for the offline provider.
34. 34 pub fn credential_vars(self) -> &'static [&'static str] {
35. 35 match self {
36. 36 Self::Gemini => &["GEMINI_API_KEY", "GOOGLE_API_KEY"],
37. 37 Self::OpenAi => &["OPENAI_API_KEY"],
38. 38 Self::Local => &[],
39. 39 }
40. 40 }
41. 41
42. 42 /// Encodings `/voice/speak` can return for this provider.
43. 43 pub fn speak_formats(self) -> &'static [SpeakFormat] {
44. 44 match self {
45. 45 Self::Gemini => &[SpeakFormat::Wav],
46. 46 Self::OpenAi | Self::Local => &[
47. 47 SpeakFormat::Wav,
48. 48 SpeakFormat::Pcm16,
49. 49 SpeakFormat::OggOpus,
50. 50 SpeakFormat::Mp3,
51. 51 ],
52. 52 }
53. 53 }
54. 54
55. 55 /// The effective route, or an actionable reason there is none. An unset
56. 56 /// provider is a configuration gap, never an implicit vendor choice.
57. 57 pub fn resolve(configured: Option<&str>) -> Result<Self, String> {
58. 58 match configured.map(str::trim).filter(|name| !name.is_empty()) {
59. 59 None => Err("Choose a voice provider in Voice settings".into()),
60. 60 Some(name) => name.parse(),
61. 61 }
62. 62 }
63. 63}
64. 64
65. 65impl FromStr for VoiceProvider {
66. 66 type Err = String;
67. 67
68. 68 fn from_str(value: &str) -> Result<Self, Self::Err> {
69. 69 Self::ALL
70. 70 .into_iter()
71. 71 .find(|provider| provider.as_str() == value)
72. 72 .ok_or_else(|| {
73. 73 format!(
74. 74 "unknown voice provider '{value}'; expected one of {}",
75. 75 Self::ALL.map(Self::as_str).join(", ")
76. 76 )
77. 77 })
78. 78 }
79. 79}
80. 80
81. 81impl fmt::Display for VoiceProvider {
82. 82 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
83. 83 f.write_str(self.as_str())
84. 84 }
85. 85}
86. 86
87. 87/// Static capability description served by `/voice/providers`. Contains no
88. 88/// credential values and no model ids.
89. 89#[derive(Debug, Clone, Serialize)]
90. 90pub struct VoiceDescriptor {
91. 91 pub name: &'static str,
92. 92 pub credential_vars: &'static [&'static str],
93. 93 pub formats: &'static [SpeakFormat],
94. 94}
95. 95
96. 96pub fn catalogue() -> Vec<VoiceDescriptor> {
97. 97 VoiceProvider::ALL
98. 98 .into_iter()
99. 99 .map(|provider| VoiceDescriptor {
100. 100 name: provider.as_str(),
101. 101 credential_vars: provider.credential_vars(),
102. 102 formats: provider.speak_formats(),
103. 103 })
104. 104 .collect()
105. 105}
106. 106
107. 107#[cfg(test)]
108. 108#[allow(clippy::expect_used, clippy::unwrap_used)]
109. 109mod tests {
110. 110 use super::*;
111. 111
112. 112 #[test]
113. 113 fn names_round_trip_and_nothing_else_parses() {
114. 114 for provider in VoiceProvider::ALL {
115. 115 assert_eq!(provider.as_str().parse::<VoiceProvider>(), Ok(provider));
116. 116 }
117. 117 for alias in ["google", "gemini-live", "google-live", "OpenAI", ""] {
118. 118 assert!(alias.parse::<VoiceProvider>().is_err(), "{alias}");
119. 119 }
120. 120 }
121. 121
122. 122 #[test]
123. 123 fn an_unset_route_is_a_gap_not_a_default() {
124. 124 assert!(VoiceProvider::resolve(None).is_err());
125. 125 assert!(VoiceProvider::resolve(Some(" ")).is_err());
126. 126 assert_eq!(
127. 127 VoiceProvider::resolve(Some(" openai ")),
128. 128 Ok(VoiceProvider::OpenAi)
129. 129 );
130. 130 }
131. 131
132. 132 #[test]
133. 133 fn catalogue_names_every_provider_and_no_secret_values() {
134. 134 let names: Vec<_> = catalogue().iter().map(|d| d.name).collect();
135. 135 assert_eq!(names, vec!["gemini", "openai", "local"]);
136. 136 let json = serde_json::to_string(&catalogue()).unwrap();
137. 137 assert!(json.contains("GEMINI_API_KEY"));
138. 138 assert!(!json.contains("KEY="));
139. 139 }
140. 140}
141. 141