muse_code_sdk/msp/method/lifecycle/
session_mcp.rs1use super::session_config_mt::SessionModelEndpointTransportOverride;
4use super::session_config_mt::SessionSettingsOverrides;
5use super::session_mcp_server::SessionMcpNameKind;
6pub use super::session_mcp_server::SessionMcpServerConfig;
7use super::session_mcp_server::validate_name;
8use serde::Deserialize;
9use serde::Deserializer;
10use serde::Serialize;
11use serde::de::Error as _;
12use std::collections::BTreeMap;
13use std::fmt;
14
15#[derive(Clone, Default, PartialEq, Eq, Serialize)]
25#[serde(rename_all = "camelCase")]
26pub struct SessionConfig {
27 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
29 pub mcp_servers: BTreeMap<String, SessionMcpServerConfig>,
30 #[serde(default, skip_serializing_if = "Option::is_none")]
33 pub settings_overrides: Option<SessionSettingsOverrides>,
34 #[serde(default, skip_serializing_if = "Option::is_none")]
37 pub model_endpoint_transport_override: Option<SessionModelEndpointTransportOverride>,
38 #[serde(default, skip_serializing_if = "Option::is_none")]
46 pub max_tool_output_bytes: Option<u64>,
47 #[serde(default, skip_serializing_if = "Option::is_none")]
55 pub allowed_built_in_tools: Option<Vec<String>>,
56 #[serde(default, skip_serializing_if = "Option::is_none")]
64 pub admit_session_mcp_servers: Option<bool>,
65 #[serde(default, skip_serializing_if = "Option::is_none")]
75 pub developer_prompt: Option<String>,
76}
77
78impl fmt::Debug for SessionConfig {
79 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
80 formatter
81 .debug_struct("SessionConfig")
82 .field(
83 "mcp_server_names",
84 &self.mcp_servers.keys().collect::<Vec<_>>(),
85 )
86 .field("settings_overrides", &self.settings_overrides)
87 .field(
88 "model_endpoint_transport_override",
89 &self.model_endpoint_transport_override,
90 )
91 .field("max_tool_output_bytes", &self.max_tool_output_bytes)
92 .field("admit_session_mcp_servers", &self.admit_session_mcp_servers)
93 .field(
94 "allowed_built_in_tool_count",
95 &self.allowed_built_in_tools.as_ref().map(Vec::len),
96 )
97 .field(
98 "developer_prompt_bytes",
99 &self.developer_prompt.as_ref().map(String::len),
100 )
101 .finish()
102 }
103}
104
105impl<'de> Deserialize<'de> for SessionConfig {
106 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
107 where
108 D: Deserializer<'de>,
109 {
110 #[derive(Deserialize)]
111 #[serde(rename_all = "camelCase")]
112 struct Wire {
113 #[serde(default)]
114 mcp_servers: BTreeMap<String, SessionMcpServerConfig>,
115 #[serde(default)]
116 settings_overrides: Option<SessionSettingsOverrides>,
117 #[serde(default)]
118 model_endpoint_transport_override: Option<SessionModelEndpointTransportOverride>,
119 #[serde(default)]
120 max_tool_output_bytes: Option<u64>,
121 #[serde(default)]
122 allowed_built_in_tools: Option<Vec<String>>,
123 }
124
125 let value = serde_json::Value::deserialize(deserializer)?;
126 let object = value
127 .as_object()
128 .ok_or_else(|| D::Error::custom("session config must be an object"))?;
129 if object
130 .get("mcpServers")
131 .is_some_and(|servers| !servers.is_object())
132 {
133 return Err(D::Error::custom(
134 "session config mcpServers must be an object",
135 ));
136 }
137 if object
138 .get("settingsOverrides")
139 .is_some_and(|overrides| !overrides.is_object())
140 {
141 return Err(D::Error::custom(
142 "session config settingsOverrides must be an object",
143 ));
144 }
145 if object
146 .get("modelEndpointTransportOverride")
147 .is_some_and(|transport| !transport.is_object())
148 {
149 return Err(D::Error::custom(
150 "session config modelEndpointTransportOverride must be an object",
151 ));
152 }
153 if object
154 .get("maxToolOutputBytes")
155 .is_some_and(|bytes| !bytes.is_u64())
156 {
157 return Err(D::Error::custom(
158 "session config maxToolOutputBytes must be a non-negative integer",
159 ));
160 }
161 if object
162 .get("allowedBuiltInTools")
163 .is_some_and(|tools| !is_non_empty_string_array(tools))
164 {
165 return Err(D::Error::custom(
166 "session config allowedBuiltInTools must be an array of non-empty strings",
167 ));
168 }
169 let admit_session_mcp_servers = match object.get("admitSessionMcpServers") {
170 None => None,
171 Some(serde_json::Value::Bool(admit)) => Some(*admit),
172 Some(_) => {
173 return Err(D::Error::custom(
174 "session config admitSessionMcpServers must be a boolean",
175 ));
176 }
177 };
178 let developer_prompt = match object.get("developerPrompt") {
179 None => None,
180 Some(serde_json::Value::Null) => Some(String::new()),
181 Some(serde_json::Value::String(text)) => Some(text.trim().to_owned()),
182 Some(_) => {
183 return Err(D::Error::custom(
184 "session config developerPrompt must be a string or null",
185 ));
186 }
187 };
188 let wire: Wire = serde_json::from_value(value).map_err(D::Error::custom)?;
189 for name in wire.mcp_servers.keys() {
190 validate_name(name, SessionMcpNameKind::Server).map_err(D::Error::custom)?;
191 }
192 Ok(Self {
193 mcp_servers: wire.mcp_servers,
194 settings_overrides: wire.settings_overrides,
195 model_endpoint_transport_override: wire.model_endpoint_transport_override,
196 max_tool_output_bytes: wire.max_tool_output_bytes,
197 allowed_built_in_tools: wire.allowed_built_in_tools,
198 admit_session_mcp_servers,
199 developer_prompt,
200 })
201 }
202}
203
204fn is_non_empty_string_array(value: &serde_json::Value) -> bool {
207 value.as_array().is_some_and(|tools| {
208 tools
209 .iter()
210 .all(|tool| tool.as_str().is_some_and(|tool| !tool.trim().is_empty()))
211 })
212}