muse_code_sdk/msp/method/lifecycle/
session_config_mt.rs1use serde::Deserialize;
4use serde::Deserializer;
5use serde::Serialize;
6use serde::de::Error as _;
7use std::collections::BTreeMap;
8use std::fmt;
9
10#[derive(Clone, Default, PartialEq, Eq, Serialize)]
20#[serde(transparent)]
21pub struct SessionSettingsOverrides {
22 values: BTreeMap<String, SessionSettingsOverrideValue>,
27}
28
29impl SessionSettingsOverrides {
30 pub fn new(
34 values: BTreeMap<String, SessionSettingsOverrideValue>,
35 ) -> Result<Self, &'static str> {
36 for key in values.keys() {
37 validate_override_key(key)?;
38 }
39 Ok(Self { values })
40 }
41
42 pub fn get(&self, key: &str) -> Option<&SessionSettingsOverrideValue> {
44 self.values.get(key)
45 }
46
47 pub fn values(&self) -> &BTreeMap<String, SessionSettingsOverrideValue> {
49 &self.values
50 }
51}
52
53impl fmt::Debug for SessionSettingsOverrides {
54 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
55 formatter
56 .debug_struct("SessionSettingsOverrides")
57 .field("key_paths", &self.values.keys().collect::<Vec<_>>())
58 .finish()
59 }
60}
61
62impl<'de> Deserialize<'de> for SessionSettingsOverrides {
63 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
64 where
65 D: Deserializer<'de>,
66 {
67 let value = serde_json::Value::deserialize(deserializer)?;
68 let object = value.as_object().ok_or_else(|| {
69 D::Error::custom("session config settingsOverrides must be an object")
70 })?;
71 let mut values = BTreeMap::new();
72 for (key, value) in object {
73 validate_override_key(key).map_err(D::Error::custom)?;
74 let value = match value {
75 serde_json::Value::String(text) => {
76 SessionSettingsOverrideValue::String(text.clone())
77 }
78 serde_json::Value::Bool(flag) => SessionSettingsOverrideValue::Bool(*flag),
79 serde_json::Value::Null => SessionSettingsOverrideValue::Null,
80 _ => {
81 return Err(D::Error::custom(
82 "session config settingsOverrides values must be strings, booleans, or null",
83 ));
84 }
85 };
86 values.insert(key.clone(), value);
87 }
88 Ok(Self { values })
89 }
90}
91
92#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
95#[serde(untagged)]
96pub enum SessionSettingsOverrideValue {
97 String(String),
99 Bool(bool),
101 Null,
103}
104
105fn validate_override_key(key: &str) -> Result<(), &'static str> {
106 if key.trim().is_empty() {
107 return Err("session config settingsOverrides keys must not be blank");
108 }
109 if key.trim() != key {
110 return Err(
111 "session config settingsOverrides keys must not contain surrounding whitespace",
112 );
113 }
114 if key.split('.').any(str::is_empty) {
115 return Err("session config settingsOverrides keys must not contain empty segments");
116 }
117 if is_secret_shaped_key(key) {
118 return Err("session config settingsOverrides contains a secret-shaped key");
119 }
120 Ok(())
121}
122
123fn is_secret_shaped_key(key: &str) -> bool {
134 const SECRET_TOKENS: &[&str] = &[
135 "secret",
136 "secrets",
137 "token",
138 "tokens",
139 "password",
140 "passphrase",
141 "passwd",
142 "pwd",
143 "credential",
144 "credentials",
145 "bearer",
146 "authorization",
147 "auth",
148 "apikey",
149 "privatekey",
150 "accesskey",
151 "cookie",
152 "cookies",
153 "key",
154 "jwt",
155 "oauth",
156 ];
157 const SECRET_STEMS: &[&str] = &[
158 "secret",
159 "password",
160 "passphrase",
161 "passwd",
162 "credential",
163 "token",
164 "apikey",
165 ];
166 let tokens = key_tokens(key);
167 if tokens
168 .iter()
169 .any(|token| SECRET_TOKENS.contains(&token.as_str()))
170 {
171 return true;
172 }
173 if tokens.iter().any(|token| {
174 SECRET_STEMS
175 .iter()
176 .any(|stem| token.len() > stem.len() && token.contains(stem))
177 }) {
178 return true;
179 }
180 if tokens
181 .iter()
182 .any(|token| token.len() > 3 && token.ends_with("key"))
183 {
184 return true;
185 }
186 tokens.windows(2).any(|pair| {
187 matches!(
188 (pair[0].as_str(), pair[1].as_str()),
189 ("api", "key")
190 | ("private", "key")
191 | ("access", "key")
192 | ("client", "secret")
193 | ("shared", "secret")
194 )
195 })
196}
197
198fn key_tokens(key: &str) -> Vec<String> {
202 let mut tokens = Vec::new();
203 for chunk in key.split(|c: char| !c.is_ascii_alphanumeric()) {
204 if chunk.is_empty() {
205 continue;
206 }
207 let chars: Vec<char> = chunk.chars().collect();
208 let mut start = 0;
209 for index in 1..chars.len() {
210 let boundary = (chars[index - 1].is_ascii_lowercase()
211 || chars[index - 1].is_ascii_digit())
212 && chars[index].is_ascii_uppercase()
213 || chars[index - 1].is_ascii_uppercase()
214 && chars[index].is_ascii_uppercase()
215 && chars.get(index + 1).is_some_and(|c| c.is_ascii_lowercase());
216 if boundary {
217 tokens.push(
218 chars[start..index]
219 .iter()
220 .collect::<String>()
221 .to_lowercase(),
222 );
223 start = index;
224 }
225 }
226 tokens.push(chars[start..].iter().collect::<String>().to_lowercase());
227 }
228 tokens
229}
230
231#[derive(Clone, Default, PartialEq, Eq, Serialize)]
238#[serde(rename_all = "camelCase")]
239pub struct SessionModelEndpointTransportOverride {
240 #[serde(default, skip_serializing_if = "Option::is_none")]
242 pub base_url: Option<String>,
243 #[serde(default, skip_serializing_if = "Option::is_none")]
245 pub allow_openai: Option<bool>,
246 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
248 pub http_headers: BTreeMap<String, String>,
249 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
251 pub env_http_headers: BTreeMap<String, String>,
252 #[serde(default, skip_serializing_if = "Option::is_none")]
254 pub proxy: Option<String>,
255 #[serde(default, skip_serializing_if = "Option::is_none")]
257 pub client_cert: Option<String>,
258 #[serde(default, skip_serializing_if = "Option::is_none")]
260 pub client_key: Option<String>,
261 #[serde(default, skip_serializing_if = "Option::is_none")]
263 pub ca_bundle: Option<String>,
264 #[serde(default, skip_serializing_if = "Option::is_none")]
266 pub auth: Option<SessionEndpointTransportAuthMode>,
267 #[serde(default, skip_serializing_if = "Option::is_none")]
271 pub providers: Option<super::SessionEndpointProviders>,
272}
273
274impl fmt::Debug for SessionModelEndpointTransportOverride {
275 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
276 formatter
277 .debug_struct("SessionModelEndpointTransportOverride")
278 .field("base_url_present", &self.base_url.is_some())
279 .field("allow_openai", &self.allow_openai)
280 .field("http_header_name_count", &self.http_headers.len())
281 .field("env_http_header_name_count", &self.env_http_headers.len())
282 .field("proxy_present", &self.proxy.is_some())
283 .field("client_cert_present", &self.client_cert.is_some())
284 .field("client_key_present", &self.client_key.is_some())
285 .field("ca_bundle_present", &self.ca_bundle.is_some())
286 .field("auth", &self.auth)
287 .field("providers", &self.providers)
288 .finish()
289 }
290}
291
292impl<'de> Deserialize<'de> for SessionModelEndpointTransportOverride {
293 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
294 where
295 D: Deserializer<'de>,
296 {
297 #[derive(Deserialize)]
298 #[serde(rename_all = "camelCase")]
299 struct Wire {
300 #[serde(default)]
301 base_url: Option<String>,
302 #[serde(default)]
303 allow_openai: Option<bool>,
304 #[serde(default)]
305 http_headers: BTreeMap<String, String>,
306 #[serde(default)]
307 env_http_headers: BTreeMap<String, String>,
308 #[serde(default)]
309 proxy: Option<String>,
310 #[serde(default)]
311 client_cert: Option<String>,
312 #[serde(default)]
313 client_key: Option<String>,
314 #[serde(default)]
315 ca_bundle: Option<String>,
316 #[serde(default)]
317 auth: Option<SessionEndpointTransportAuthMode>,
318 #[serde(default)]
319 providers: Option<super::SessionEndpointProviders>,
320 }
321
322 let value = serde_json::Value::deserialize(deserializer)?;
323 if !value.is_object() {
324 return Err(D::Error::custom(
325 "session config modelEndpointTransportOverride must be an object",
326 ));
327 }
328 let wire: Wire = serde_json::from_value(value).map_err(|_| {
329 D::Error::custom(
330 "session config modelEndpointTransportOverride has a field with the wrong type or an unknown option",
331 )
332 })?;
333 super::session_config_mt_providers::check_header_names(
334 wire.http_headers.keys().chain(wire.env_http_headers.keys()),
335 )
336 .map_err(D::Error::custom)?;
337 Ok(Self {
338 base_url: wire.base_url,
339 allow_openai: wire.allow_openai,
340 http_headers: wire.http_headers,
341 env_http_headers: wire.env_http_headers,
342 proxy: wire.proxy,
343 client_cert: wire.client_cert,
344 client_key: wire.client_key,
345 ca_bundle: wire.ca_bundle,
346 auth: wire.auth,
347 providers: wire.providers,
348 })
349 }
350}
351
352#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
356#[serde(rename_all = "lowercase")]
357pub enum SessionEndpointTransportAuthMode {
358 #[default]
360 Bearer,
361 None,
363}