Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Unblock typed runtime integration config primitives

Yeachan-Heo30f436c8128c
diff --git a/rust/crates/runtime/src/config.rs b/rust/crates/runtime/src/config.rs
index 49395573..559ae6a4 100644
--- a/rust/crates/runtime/src/config.rs
+++ b/rust/crates/runtime/src/config.rs
@@ -24,6 +24,95 @@ pub struct ConfigEntry {
pub struct RuntimeConfig {
merged: BTreeMap<String, JsonValue>,
loaded_entries: Vec<ConfigEntry>,
+ feature_config: RuntimeFeatureConfig,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct RuntimeFeatureConfig {
+ mcp: McpConfigCollection,
+ oauth: Option<OAuthConfig>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct McpConfigCollection {
+ servers: BTreeMap<String, ScopedMcpServerConfig>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScopedMcpServerConfig {
+ pub scope: ConfigSource,
+ pub config: McpServerConfig,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum McpTransport {
+ Stdio,
+ Sse,
+ Http,
+ Ws,
+ Sdk,
+ ClaudeAiProxy,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum McpServerConfig {
+ Stdio(McpStdioServerConfig),
+ Sse(McpRemoteServerConfig),
+ Http(McpRemoteServerConfig),
+ Ws(McpWebSocketServerConfig),
+ Sdk(McpSdkServerConfig),
+ ClaudeAiProxy(McpClaudeAiProxyServerConfig),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpStdioServerConfig {
+ pub command: String,
+ pub args: Vec<String>,
+ pub env: BTreeMap<String, String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpRemoteServerConfig {
+ pub url: String,
+ pub headers: BTreeMap<String, String>,
+ pub headers_helper: Option<String>,
+ pub oauth: Option<McpOAuthConfig>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpWebSocketServerConfig {
+ pub url: String,
+ pub headers: BTreeMap<String, String>,
+ pub headers_helper: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpSdkServerConfig {
+ pub name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpClaudeAiProxyServerConfig {
+ pub url: String,
+ pub id: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct McpOAuthConfig {
+ pub client_id: Option<String>,
+ pub callback_port: Option<u16>,
+ pub auth_server_metadata_url: Option<String>,
+ pub xaa: Option<bool>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct OAuthConfig {
+ pub client_id: String,
+ pub authorize_url: String,
+ pub token_url: String,
+ pub callback_port: Option<u16>,
+ pub manual_redirect_url: Option<String>,
+ pub scopes: Vec<String>,
}
#[derive(Debug)]
@@ -95,18 +184,31 @@ impl ConfigLoader {
pub fn load(&self) -> Result<RuntimeConfig, ConfigError> {
let mut merged = BTreeMap::new();
let mut loaded_entries = Vec::new();
+ let mut mcp_servers = BTreeMap::new();
for entry in self.discover() {
let Some(value) = read_optional_json_object(&entry.path)? else {
continue;
};
+ merge_mcp_servers(&mut mcp_servers, entry.source, &value, &entry.path)?;
deep_merge_objects(&mut merged, &value);
loaded_entries.push(entry);
}
+ let feature_config = RuntimeFeatureConfig {
+ mcp: McpConfigCollection {
+ servers: mcp_servers,
+ },
+ oauth: parse_optional_oauth_config(
+ &JsonValue::Object(merged.clone()),
+ "merged settings.oauth",
+ )?,
+ };
+
Ok(RuntimeConfig {
merged,
loaded_entries,
+ feature_config,
})
}
}
@@ -117,6 +219,7 @@ impl RuntimeConfig {
Self {
merged: BTreeMap::new(),
loaded_entries: Vec::new(),
+ feature_config: RuntimeFeatureConfig::default(),
}
}
@@ -139,6 +242,66 @@ impl RuntimeConfig {
pub fn as_json(&self) -> JsonValue {
JsonValue::Object(self.merged.clone())
}
+
+ #[must_use]
+ pub fn feature_config(&self) -> &RuntimeFeatureConfig {
+ &self.feature_config
+ }
+
+ #[must_use]
+ pub fn mcp(&self) -> &McpConfigCollection {
+ &self.feature_config.mcp
+ }
+
+ #[must_use]
+ pub fn oauth(&self) -> Option<&OAuthConfig> {
+ self.feature_config.oauth.as_ref()
+ }
+}
+
+impl RuntimeFeatureConfig {
+ #[must_use]
+ pub fn mcp(&self) -> &McpConfigCollection {
+ &self.mcp
+ }
+
+ #[must_use]
+ pub fn oauth(&self) -> Option<&OAuthConfig> {
+ self.oauth.as_ref()
+ }
+}
+
+impl McpConfigCollection {
+ #[must_use]
+ pub fn servers(&self) -> &BTreeMap<String, ScopedMcpServerConfig> {
+ &self.servers
+ }
+
+ #[must_use]
+ pub fn get(&self, name: &str) -> Option<&ScopedMcpServerConfig> {
+ self.servers.get(name)
+ }
+}
+
+impl ScopedMcpServerConfig {
+ #[must_use]
+ pub fn transport(&self) -> McpTransport {
+ self.config.transport()
+ }
+}
+
+impl McpServerConfig {
+ #[must_use]
+ pub fn transport(&self) -> McpTransport {
+ match self {
+ Self::Stdio(_) => McpTransport::Stdio,
+ Self::Sse(_) => McpTransport::Sse,
+ Self::Http(_) => McpTransport::Http,
+ Self::Ws(_) => McpTransport::Ws,
+ Self::Sdk(_) => McpTransport::Sdk,
+ Self::ClaudeAiProxy(_) => McpTransport::ClaudeAiProxy,
+ }
+ }
}
fn read_optional_json_object(
@@ -165,6 +328,253 @@ fn read_optional_json_object(
Ok(Some(object.clone()))
}
+fn merge_mcp_servers(
+ target: &mut BTreeMap<String, ScopedMcpServerConfig>,
+ source: ConfigSource,
+ root: &BTreeMap<String, JsonValue>,
+ path: &Path,
+) -> Result<(), ConfigError> {
+ let Some(mcp_servers) = root.get("mcpServers") else {
+ return Ok(());
+ };
+ let servers = expect_object(mcp_servers, &format!("{}: mcpServers", path.display()))?;
+ for (name, value) in servers {
+ let parsed = parse_mcp_server_config(
+ name,
+ value,
+ &format!("{}: mcpServers.{name}", path.display()),
+ )?;
+ target.insert(
+ name.clone(),
+ ScopedMcpServerConfig {
+ scope: source,
+ config: parsed,
+ },
+ );
+ }
+ Ok(())
+}
+
+fn parse_optional_oauth_config(
+ root: &JsonValue,
+ context: &str,
+) -> Result<Option<OAuthConfig>, ConfigError> {
+ let Some(oauth_value) = root.as_object().and_then(|object| object.get("oauth")) else {
+ return Ok(None);
+ };
+ let object = expect_object(oauth_value, context)?;
+ let client_id = expect_string(object, "clientId", context)?.to_string();
+ let authorize_url = expect_string(object, "authorizeUrl", context)?.to_string();
+ let token_url = expect_string(object, "tokenUrl", context)?.to_string();
+ let callback_port = optional_u16(object, "callbackPort", context)?;
+ let manual_redirect_url =
+ optional_string(object, "manualRedirectUrl", context)?.map(str::to_string);
+ let scopes = optional_string_array(object, "scopes", context)?.unwrap_or_default();
+ Ok(Some(OAuthConfig {
+ client_id,
+ authorize_url,
+ token_url,
+ callback_port,
+ manual_redirect_url,
+ scopes,
+ }))
+}
+
+fn parse_mcp_server_config(
+ server_name: &str,
+ value: &JsonValue,
+ context: &str,
+) -> Result<McpServerConfig, ConfigError> {
+ let object = expect_object(value, context)?;
+ let server_type = optional_string(object, "type", context)?.unwrap_or("stdio");
+ match server_type {
+ "stdio" => Ok(McpServerConfig::Stdio(McpStdioServerConfig {
+ command: expect_string(object, "command", context)?.to_string(),
+ args: optional_string_array(object, "args", context)?.unwrap_or_default(),
+ env: optional_string_map(object, "env", context)?.unwrap_or_default(),
+ })),
+ "sse" => Ok(McpServerConfig::Sse(parse_mcp_remote_server_config(
+ object, context,
+ )?)),
+ "http" => Ok(McpServerConfig::Http(parse_mcp_remote_server_config(
+ object, context,
+ )?)),
+ "ws" => Ok(McpServerConfig::Ws(McpWebSocketServerConfig {
+ url: expect_string(object, "url", context)?.to_string(),
+ headers: optional_string_map(object, "headers", context)?.unwrap_or_default(),
+ headers_helper: optional_string(object, "headersHelper", context)?.map(str::to_string),
+ })),
+ "sdk" => Ok(McpServerConfig::Sdk(McpSdkServerConfig {
+ name: expect_string(object, "name", context)?.to_string(),
+ })),
+ "claudeai-proxy" => Ok(McpServerConfig::ClaudeAiProxy(
+ McpClaudeAiProxyServerConfig {
+ url: expect_string(object, "url", context)?.to_string(),
+ id: expect_string(object, "id", context)?.to_string(),
+ },
+ )),
+ other => Err(ConfigError::Parse(format!(
+ "{context}: unsupported MCP server type for {server_name}: {other}"
+ ))),
+ }
+}
+
+fn parse_mcp_remote_server_config(
+ object: &BTreeMap<String, JsonValue>,
+ context: &str,
+) -> Result<McpRemoteServerConfig, ConfigError> {
+ Ok(McpRemoteServerConfig {
+ url: expect_string(object, "url", context)?.to_string(),
+ headers: optional_string_map(object, "headers", context)?.unwrap_or_default(),
+ headers_helper: optional_string(object, "headersHelper", context)?.map(str::to_string),
+ oauth: parse_optional_mcp_oauth_config(object, context)?,
+ })
+}
+
+fn parse_optional_mcp_oauth_config(
+ object: &BTreeMap<String, JsonValue>,
+ context: &str,
+) -> Result<Option<McpOAuthConfig>, ConfigError> {
+ let Some(value) = object.get("oauth") else {
+ return Ok(None);
+ };
+ let oauth = expect_object(value, &format!("{context}.oauth"))?;
+ Ok(Some(McpOAuthConfig {
+ client_id: optional_string(oauth, "clientId", context)?.map(str::to_string),
+ callback_port: optional_u16(oauth, "callbackPort", context)?,
+ auth_server_metadata_url: optional_string(oauth, "authServerMetadataUrl", context)?
+ .map(str::to_string),
+ xaa: optional_bool(oauth, "xaa", context)?,
+ }))
+}
+
+fn expect_object<'a>(
+ value: &'a JsonValue,
+ context: &str,
+) -> Result<&'a BTreeMap<String, JsonValue>, ConfigError> {
+ value
+ .as_object()
+ .ok_or_else(|| ConfigError::Parse(format!("{context}: expected JSON object")))
+}
+
+fn expect_string<'a>(
+ object: &'a BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<&'a str, ConfigError> {
+ object
+ .get(key)
+ .and_then(JsonValue::as_str)
+ .ok_or_else(|| ConfigError::Parse(format!("{context}: missing string field {key}")))
+}
+
+fn optional_string<'a>(
+ object: &'a BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<Option<&'a str>, ConfigError> {
+ match object.get(key) {
+ Some(value) => value
+ .as_str()
+ .map(Some)
+ .ok_or_else(|| ConfigError::Parse(format!("{context}: field {key} must be a string"))),
+ None => Ok(None),
+ }
+}
+
+fn optional_bool(
+ object: &BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<Option<bool>, ConfigError> {
+ match object.get(key) {
+ Some(value) => value
+ .as_bool()
+ .map(Some)
+ .ok_or_else(|| ConfigError::Parse(format!("{context}: field {key} must be a boolean"))),
+ None => Ok(None),
+ }
+}
+
+fn optional_u16(
+ object: &BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<Option<u16>, ConfigError> {
+ match object.get(key) {
+ Some(value) => {
+ let Some(number) = value.as_i64() else {
+ return Err(ConfigError::Parse(format!(
+ "{context}: field {key} must be an integer"
+ )));
+ };
+ let number = u16::try_from(number).map_err(|_| {
+ ConfigError::Parse(format!("{context}: field {key} is out of range"))
+ })?;
+ Ok(Some(number))
+ }
+ None => Ok(None),
+ }
+}
+
+fn optional_string_array(
+ object: &BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<Option<Vec<String>>, ConfigError> {
+ match object.get(key) {
+ Some(value) => {
+ let Some(array) = value.as_array() else {
+ return Err(ConfigError::Parse(format!(
+ "{context}: field {key} must be an array"
+ )));
+ };
+ array
+ .iter()
+ .map(|item| {
+ item.as_str().map(ToOwned::to_owned).ok_or_else(|| {
+ ConfigError::Parse(format!(
+ "{context}: field {key} must contain only strings"
+ ))
+ })
+ })
+ .collect::<Result<Vec<_>, _>>()
+ .map(Some)
+ }
+ None => Ok(None),
+ }
+}
+
+fn optional_string_map(
+ object: &BTreeMap<String, JsonValue>,
+ key: &str,
+ context: &str,
+) -> Result<Option<BTreeMap<String, String>>, ConfigError> {
+ match object.get(key) {
+ Some(value) => {
+ let Some(map) = value.as_object() else {
+ return Err(ConfigError::Parse(format!(
+ "{context}: field {key} must be an object"
+ )));
+ };
+ map.iter()
+ .map(|(entry_key, entry_value)| {
+ entry_value
+ .as_str()
+ .map(|text| (entry_key.clone(), text.to_string()))
+ .ok_or_else(|| {
+ ConfigError::Parse(format!(
+ "{context}: field {key} must contain only string values"
+ ))
+ })
+ })
+ .collect::<Result<BTreeMap<_, _>, _>>()
+ .map(Some)
+ }
+ None => Ok(None),
+ }
+}
+
fn deep_merge_objects(
target: &mut BTreeMap<String, JsonValue>,
source: &BTreeMap<String, JsonValue>,
@@ -183,7 +593,9 @@ fn deep_merge_objects(
#[cfg(test)]
mod tests {
- use super::{ConfigLoader, ConfigSource, CLAUDE_CODE_SETTINGS_SCHEMA_NAME};
+ use super::{
+ ConfigLoader, ConfigSource, McpServerConfig, McpTransport, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
+ };
use crate::json::JsonValue;
use std::fs;
use std::time::{SystemTime, UNIX_EPOCH};
@@ -266,4 +678,118 @@ mod tests {
fs::remove_dir_all(root).expect("cleanup temp dir");
}
+
+ #[test]
+ fn parses_typed_mcp_and_oauth_config() {
+ let root = temp_dir();
+ let cwd = root.join("project");
+ let home = root.join("home").join(".claude");
+ fs::create_dir_all(cwd.join(".claude")).expect("project config dir");
+ fs::create_dir_all(&home).expect("home config dir");
+
+ fs::write(
+ home.join("settings.json"),
+ r#"{
+ "mcpServers": {
+ "stdio-server": {
+ "command": "uvx",
+ "args": ["mcp-server"],
+ "env": {"TOKEN": "secret"}
+ },
+ "remote-server": {
+ "type": "http",
+ "url": "https://example.test/mcp",
+ "headers": {"Authorization": "Bearer token"},
+ "headersHelper": "helper.sh",
+ "oauth": {
+ "clientId": "mcp-client",
+ "callbackPort": 7777,
+ "authServerMetadataUrl": "https://issuer.test/.well-known/oauth-authorization-server",
+ "xaa": true
+ }
+ }
+ },
+ "oauth": {
+ "clientId": "runtime-client",
+ "authorizeUrl": "https://console.test/oauth/authorize",
+ "tokenUrl": "https://console.test/oauth/token",
+ "callbackPort": 54545,
+ "manualRedirectUrl": "https://console.test/oauth/callback",
+ "scopes": ["org:read", "user:write"]
+ }
+ }"#,
+ )
+ .expect("write user settings");
+ fs::write(
+ cwd.join(".claude").join("settings.local.json"),
+ r#"{
+ "mcpServers": {
+ "remote-server": {
+ "type": "ws",
+ "url": "wss://override.test/mcp",
+ "headers": {"X-Env": "local"}
+ }
+ }
+ }"#,
+ )
+ .expect("write local settings");
+
+ let loaded = ConfigLoader::new(&cwd, &home)
+ .load()
+ .expect("config should load");
+
+ let stdio_server = loaded
+ .mcp()
+ .get("stdio-server")
+ .expect("stdio server should exist");
+ assert_eq!(stdio_server.scope, ConfigSource::User);
+ assert_eq!(stdio_server.transport(), McpTransport::Stdio);
+
+ let remote_server = loaded
+ .mcp()
+ .get("remote-server")
+ .expect("remote server should exist");
+ assert_eq!(remote_server.scope, ConfigSource::Local);
+ assert_eq!(remote_server.transport(), McpTransport::Ws);
+ match &remote_server.config {
+ McpServerConfig::Ws(config) => {
+ assert_eq!(config.url, "wss://override.test/mcp");
+ assert_eq!(
+ config.headers.get("X-Env").map(String::as_str),
+ Some("local")
+ );
+ }
+ other => panic!("expected ws config, got {other:?}"),
+ }
+
+ let oauth = loaded.oauth().expect("oauth config should exist");
+ assert_eq!(oauth.client_id, "runtime-client");
+ assert_eq!(oauth.callback_port, Some(54_545));
+ assert_eq!(oauth.scopes, vec!["org:read", "user:write"]);
+
+ fs::remove_dir_all(root).expect("cleanup temp dir");
+ }
+
+ #[test]
+ fn rejects_invalid_mcp_server_shapes() {
+ let root = temp_dir();
+ let cwd = root.join("project");
+ let home = root.join("home").join(".claude");
+ fs::create_dir_all(&home).expect("home config dir");
+ fs::create_dir_all(&cwd).expect("project dir");
+ fs::write(
+ home.join("settings.json"),
+ r#"{"mcpServers":{"broken":{"type":"http","url":123}}}"#,
+ )
+ .expect("write broken settings");
+
+ let error = ConfigLoader::new(&cwd, &home)
+ .load()
+ .expect_err("config should fail");
+ assert!(error
+ .to_string()
+ .contains("mcpServers.broken: missing string field url"));
+
+ fs::remove_dir_all(root).expect("cleanup temp dir");
+ }
}
diff --git a/rust/crates/runtime/src/file_ops.rs b/rust/crates/runtime/src/file_ops.rs
index 42b3babe..e18bed79 100644
--- a/rust/crates/runtime/src/file_ops.rs
+++ b/rust/crates/runtime/src/file_ops.rs
@@ -138,9 +138,9 @@ pub fn read_file(
let content = fs::read_to_string(&absolute_path)?;
let lines: Vec<&str> = content.lines().collect();
let start_index = offset.unwrap_or(0).min(lines.len());
- let end_index = limit
- .map(|limit| start_index.saturating_add(limit).min(lines.len()))
- .unwrap_or(lines.len());
+ let end_index = limit.map_or(lines.len(), |limit| {
+ start_index.saturating_add(limit).min(lines.len())
+ });
let selected = lines[start_index..end_index].join("\n");
Ok(ReadFileOutput {
@@ -296,12 +296,12 @@ pub fn grep_search(input: &GrepSearchInput) -> io::Result<GrepSearchOutput> {
continue;
}
- let Ok(content) = fs::read_to_string(&file_path) else {
+ let Ok(file_content) = fs::read_to_string(&file_path) else {
continue;
};
if output_mode == "count" {
- let count = regex.find_iter(&content).count();
+ let count = regex.find_iter(&file_content).count();
if count > 0 {
filenames.push(file_path.to_string_lossy().into_owned());
total_matches += count;
@@ -309,7 +309,7 @@ pub fn grep_search(input: &GrepSearchInput) -> io::Result<GrepSearchOutput> {
continue;
}
- let lines: Vec<&str> = content.lines().collect();
+ let lines: Vec<&str> = file_content.lines().collect();
let mut matched_lines = Vec::new();
for (index, line) in lines.iter().enumerate() {
if regex.is_match(line) {
@@ -327,13 +327,13 @@ pub fn grep_search(input: &GrepSearchInput) -> io::Result<GrepSearchOutput> {
for index in matched_lines {
let start = index.saturating_sub(input.before.unwrap_or(context));
let end = (index + input.after.unwrap_or(context) + 1).min(lines.len());
- for current in start..end {
+ for (current, line_content) in lines.iter().enumerate().take(end).skip(start) {
let prefix = if input.line_numbers.unwrap_or(true) {
format!("{}:{}:", file_path.to_string_lossy(), current + 1)
} else {
format!("{}:", file_path.to_string_lossy())
};
- content_lines.push(format!("{prefix}{}", lines[current]));
+ content_lines.push(format!("{prefix}{line_content}"));
}
}
}
@@ -341,7 +341,7 @@ pub fn grep_search(input: &GrepSearchInput) -> io::Result<GrepSearchOutput> {
let (filenames, applied_limit, applied_offset) =
apply_limit(filenames, input.head_limit, input.offset);
- let content = if output_mode == "content" {
+ let rendered_content = if output_mode == "content" {
let (lines, limit, offset) = apply_limit(content_lines, input.head_limit, input.offset);
return Ok(GrepSearchOutput {
mode: Some(output_mode),
@@ -361,7 +361,7 @@ pub fn grep_search(input: &GrepSearchInput) -> io::Result<GrepSearchOutput> {
mode: Some(output_mode.clone()),
num_files: filenames.len(),
filenames,
- content,
+ content: rendered_content,
num_lines: None,
num_matches: (output_mode == "count").then_some(total_matches),
applied_limit,
@@ -376,8 +376,7 @@ fn collect_search_files(base_path: &Path) -> io::Result<Vec<PathBuf>> {
let mut files = Vec::new();
for entry in WalkDir::new(base_path) {
- let entry =
- entry.map_err(|error| io::Error::new(io::ErrorKind::Other, error.to_string()))?;
+ let entry = entry.map_err(|error| io::Error::other(error.to_string()))?;
if entry.file_type().is_file() {
files.push(entry.path().to_path_buf());
}
diff --git a/rust/crates/runtime/src/lib.rs b/rust/crates/runtime/src/lib.rs
index 0cb58145..358d3673 100644
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@ -17,8 +17,10 @@ pub use compact::{
get_compact_continuation_message, should_compact, CompactionConfig, CompactionResult,
};
pub use config::{
- ConfigEntry, ConfigError, ConfigLoader, ConfigSource, RuntimeConfig,
- CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
+ ConfigEntry, ConfigError, ConfigLoader, ConfigSource, McpClaudeAiProxyServerConfig,
+ McpConfigCollection, McpOAuthConfig, McpRemoteServerConfig, McpSdkServerConfig,
+ McpServerConfig, McpStdioServerConfig, McpTransport, McpWebSocketServerConfig, OAuthConfig,
+ RuntimeConfig, RuntimeFeatureConfig, ScopedMcpServerConfig, CLAUDE_CODE_SETTINGS_SCHEMA_NAME,
};
pub use conversation::{
ApiClient, ApiRequest, AssistantEvent, ConversationRuntime, RuntimeError, StaticToolExecutor,