use serde::Deserialize;
use serde::Deserializer;
use serde::Serialize;
use serde::de::Error as _;
use std::collections::BTreeMap;
use std::fmt;
#[derive(Clone, Default, PartialEq, Eq, Serialize)]
#[serde(transparent)]
pub struct SessionSettingsOverrides {
values: BTreeMap<String, SessionSettingsOverrideValue>,
}
impl SessionSettingsOverrides {
pub fn new(
values: BTreeMap<String, SessionSettingsOverrideValue>,
) -> Result<Self, &'static str> {
for key in values.keys() {
validate_override_key(key)?;
}
Ok(Self { values })
}
pub fn get(&self, key: &str) -> Option<&SessionSettingsOverrideValue> {
self.values.get(key)
}
pub fn values(&self) -> &BTreeMap<String, SessionSettingsOverrideValue> {
&self.values
}
}
impl fmt::Debug for SessionSettingsOverrides {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("SessionSettingsOverrides")
.field("key_paths", &self.values.keys().collect::<Vec<_>>())
.finish()
}
}
impl<'de> Deserialize<'de> for SessionSettingsOverrides {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = serde_json::Value::deserialize(deserializer)?;
let object = value.as_object().ok_or_else(|| {
D::Error::custom("session config settingsOverrides must be an object")
})?;
let mut values = BTreeMap::new();
for (key, value) in object {
validate_override_key(key).map_err(D::Error::custom)?;
let value = match value {
serde_json::Value::String(text) => {
SessionSettingsOverrideValue::String(text.clone())
}
serde_json::Value::Bool(flag) => SessionSettingsOverrideValue::Bool(*flag),
serde_json::Value::Null => SessionSettingsOverrideValue::Null,
_ => {
return Err(D::Error::custom(
"session config settingsOverrides values must be strings, booleans, or null",
));
}
};
values.insert(key.clone(), value);
}
Ok(Self { values })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SessionSettingsOverrideValue {
String(String),
Bool(bool),
Null,
}
fn validate_override_key(key: &str) -> Result<(), &'static str> {
if key.trim().is_empty() {
return Err("session config settingsOverrides keys must not be blank");
}
if key.trim() != key {
return Err(
"session config settingsOverrides keys must not contain surrounding whitespace",
);
}
if key.split('.').any(str::is_empty) {
return Err("session config settingsOverrides keys must not contain empty segments");
}
if is_secret_shaped_key(key) {
return Err("session config settingsOverrides contains a secret-shaped key");
}
Ok(())
}
fn is_secret_shaped_key(key: &str) -> bool {
const SECRET_TOKENS: &[&str] = &[
"secret",
"secrets",
"token",
"tokens",
"password",
"passphrase",
"passwd",
"pwd",
"credential",
"credentials",
"bearer",
"authorization",
"auth",
"apikey",
"privatekey",
"accesskey",
"cookie",
"cookies",
"key",
"jwt",
"oauth",
];
const SECRET_STEMS: &[&str] = &[
"secret",
"password",
"passphrase",
"passwd",
"credential",
"token",
"apikey",
];
let tokens = key_tokens(key);
if tokens
.iter()
.any(|token| SECRET_TOKENS.contains(&token.as_str()))
{
return true;
}
if tokens.iter().any(|token| {
SECRET_STEMS
.iter()
.any(|stem| token.len() > stem.len() && token.contains(stem))
}) {
return true;
}
if tokens
.iter()
.any(|token| token.len() > 3 && token.ends_with("key"))
{
return true;
}
tokens.windows(2).any(|pair| {
matches!(
(pair[0].as_str(), pair[1].as_str()),
("api", "key")
| ("private", "key")
| ("access", "key")
| ("client", "secret")
| ("shared", "secret")
)
})
}
fn key_tokens(key: &str) -> Vec<String> {
let mut tokens = Vec::new();
for chunk in key.split(|c: char| !c.is_ascii_alphanumeric()) {
if chunk.is_empty() {
continue;
}
let chars: Vec<char> = chunk.chars().collect();
let mut start = 0;
for index in 1..chars.len() {
let boundary = (chars[index - 1].is_ascii_lowercase()
|| chars[index - 1].is_ascii_digit())
&& chars[index].is_ascii_uppercase()
|| chars[index - 1].is_ascii_uppercase()
&& chars[index].is_ascii_uppercase()
&& chars.get(index + 1).is_some_and(|c| c.is_ascii_lowercase());
if boundary {
tokens.push(
chars[start..index]
.iter()
.collect::<String>()
.to_lowercase(),
);
start = index;
}
}
tokens.push(chars[start..].iter().collect::<String>().to_lowercase());
}
tokens
}
#[derive(Clone, Default, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionModelEndpointTransportOverride {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub base_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allow_openai: Option<bool>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub http_headers: BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub env_http_headers: BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub proxy: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_cert: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_key: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ca_bundle: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub auth: Option<SessionEndpointTransportAuthMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub providers: Option<super::SessionEndpointProviders>,
}
impl fmt::Debug for SessionModelEndpointTransportOverride {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("SessionModelEndpointTransportOverride")
.field("base_url_present", &self.base_url.is_some())
.field("allow_openai", &self.allow_openai)
.field("http_header_name_count", &self.http_headers.len())
.field("env_http_header_name_count", &self.env_http_headers.len())
.field("proxy_present", &self.proxy.is_some())
.field("client_cert_present", &self.client_cert.is_some())
.field("client_key_present", &self.client_key.is_some())
.field("ca_bundle_present", &self.ca_bundle.is_some())
.field("auth", &self.auth)
.field("providers", &self.providers)
.finish()
}
}
impl<'de> Deserialize<'de> for SessionModelEndpointTransportOverride {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Wire {
#[serde(default)]
base_url: Option<String>,
#[serde(default)]
allow_openai: Option<bool>,
#[serde(default)]
http_headers: BTreeMap<String, String>,
#[serde(default)]
env_http_headers: BTreeMap<String, String>,
#[serde(default)]
proxy: Option<String>,
#[serde(default)]
client_cert: Option<String>,
#[serde(default)]
client_key: Option<String>,
#[serde(default)]
ca_bundle: Option<String>,
#[serde(default)]
auth: Option<SessionEndpointTransportAuthMode>,
#[serde(default)]
providers: Option<super::SessionEndpointProviders>,
}
let value = serde_json::Value::deserialize(deserializer)?;
if !value.is_object() {
return Err(D::Error::custom(
"session config modelEndpointTransportOverride must be an object",
));
}
let wire: Wire = serde_json::from_value(value).map_err(|_| {
D::Error::custom(
"session config modelEndpointTransportOverride has a field with the wrong type or an unknown option",
)
})?;
super::session_config_mt_providers::check_header_names(
wire.http_headers.keys().chain(wire.env_http_headers.keys()),
)
.map_err(D::Error::custom)?;
Ok(Self {
base_url: wire.base_url,
allow_openai: wire.allow_openai,
http_headers: wire.http_headers,
env_http_headers: wire.env_http_headers,
proxy: wire.proxy,
client_cert: wire.client_cert,
client_key: wire.client_key,
ca_bundle: wire.ca_bundle,
auth: wire.auth,
providers: wire.providers,
})
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SessionEndpointTransportAuthMode {
#[default]
Bearer,
None,
}