Skip to content

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

Rust

feat(runtime): implement per-session settings override & schema validation (#3346)

Bellmand9d5d5da0879
diff --git a/rust/crates/runtime/src/lib.rs b/rust/crates/runtime/src/lib.rs
index 8bcc30f5..dbb658a9 100644
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@ -41,6 +41,7 @@ mod report_schema;
pub mod sandbox;
mod session;
pub mod session_control;
+pub mod session_settings;
pub mod trident;
pub use session_control::SessionStore;
mod sse;
@@ -179,6 +180,10 @@ pub use session::{
ContentBlock, ConversationMessage, MessageRole, Session, SessionCompaction, SessionError,
SessionFork, SessionHeartbeat, SessionLiveness, SessionPromptEntry,
};
+pub use session_settings::{
+ ConfigHotreloadMonitor, SettingApplicator, SettingCategory, SettingSchema, SettingSchemaRegistry,
+ SettingType, SessionSettings,
+};
pub use sse::{IncrementalSseParser, SseEvent};
pub use stale_base::{
check_base_commit, format_stale_base_warning, read_claw_base_file, resolve_expected_base,
diff --git a/rust/crates/runtime/src/session_settings.rs b/rust/crates/runtime/src/session_settings.rs
new file mode 100644
index 00000000..0bb494c6
--- /dev/null
+++ b/rust/crates/runtime/src/session_settings.rs
@@ -0,0 +1,1319 @@
+use std::collections::BTreeMap;
+use std::fmt::{Display, Formatter};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::json::JsonValue;
+
+/// Classification of a setting by its category.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SettingCategory {
+ Model,
+ Behavior,
+ Ux,
+ Advanced,
+}
+
+impl Display for SettingCategory {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Model => write!(f, "model"),
+ Self::Behavior => write!(f, "behavior"),
+ Self::Ux => write!(f, "ux"),
+ Self::Advanced => write!(f, "advanced"),
+ }
+ }
+}
+
+/// Type of a setting value for schema validation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SettingType {
+ String,
+ Number,
+ Boolean,
+ Object,
+}
+
+impl Display for SettingType {
+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::String => write!(f, "string"),
+ Self::Number => write!(f, "number"),
+ Self::Boolean => write!(f, "boolean"),
+ Self::Object => write!(f, "object"),
+ }
+ }
+}
+
+/// Schema definition for a single overridable setting.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SettingSchema {
+ /// Unique identifier for this setting
+ pub name: String,
+ /// Human-readable description
+ pub description: String,
+ /// Expected type of the value
+ pub value_type: SettingType,
+ /// Setting category (model, behavior, UX, advanced)
+ pub category: SettingCategory,
+ /// Whether this setting can be overridden at runtime
+ pub overridable: bool,
+ /// Default value if not specified
+ pub default_value: Option<JsonValue>,
+ /// Allowed values (for string/enum settings), if restricted
+ pub allowed_values: Option<Vec<JsonValue>>,
+}
+
+impl SettingSchema {
+ /// Create a new setting schema with minimal required fields.
+ pub fn new(
+ name: impl Into<String>,
+ description: impl Into<String>,
+ value_type: SettingType,
+ category: SettingCategory,
+ ) -> Self {
+ Self {
+ name: name.into(),
+ description: description.into(),
+ value_type,
+ category,
+ overridable: true,
+ default_value: None,
+ allowed_values: None,
+ }
+ }
+
+ /// Set the default value for this setting.
+ pub fn with_default(mut self, default: JsonValue) -> Self {
+ self.default_value = Some(default);
+ self
+ }
+
+ /// Set whether this setting can be overridden.
+ pub fn with_overridable(mut self, overridable: bool) -> Self {
+ self.overridable = overridable;
+ self
+ }
+
+ /// Set allowed values for this setting (for enum-like settings).
+ pub fn with_allowed_values(mut self, allowed: Vec<JsonValue>) -> Self {
+ self.allowed_values = Some(allowed);
+ self
+ }
+
+ /// Validate a value against this schema.
+ pub fn validate(&self, value: &JsonValue) -> Result<(), String> {
+ // Type check
+ match (self.value_type, value) {
+ (SettingType::String, JsonValue::String(_)) => {}
+ (SettingType::Number, JsonValue::Number(_)) => {}
+ (SettingType::Boolean, JsonValue::Bool(_)) => {}
+ (SettingType::Object, JsonValue::Object(_)) => {}
+ _ => {
+ return Err(format!(
+ "Setting '{}' expects {}, got {}",
+ self.name,
+ self.value_type,
+ value_type_label(value)
+ ))
+ }
+ }
+
+ // Allowed values check
+ if let Some(ref allowed) = self.allowed_values {
+ if !allowed.contains(value) {
+ return Err(format!(
+ "Setting '{}' value not in allowed list: {:?}",
+ self.name, allowed
+ ));
+ }
+ }
+
+ Ok(())
+ }
+}
+
+/// Settings that can be overridden at the session level.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct SessionSettings {
+ /// Global settings (from runtime config)
+ pub global: BTreeMap<String, JsonValue>,
+ /// Session-specific overrides
+ pub session_overrides: BTreeMap<String, JsonValue>,
+ /// Per-request overrides
+ pub request_overrides: BTreeMap<String, JsonValue>,
+}
+
+impl SessionSettings {
+ /// Create a new session settings container.
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Set a global setting.
+ pub fn set_global(&mut self, name: impl Into<String>, value: JsonValue) {
+ self.global.insert(name.into(), value);
+ }
+
+ /// Set a session-level override.
+ pub fn set_session_override(&mut self, name: impl Into<String>, value: JsonValue) {
+ self.session_overrides.insert(name.into(), value);
+ }
+
+ /// Set a per-request override.
+ pub fn set_request_override(&mut self, name: impl Into<String>, value: JsonValue) {
+ self.request_overrides.insert(name.into(), value);
+ }
+
+ /// Get effective value for a setting, applying the override hierarchy:
+ /// request > session > global > default
+ pub fn get_effective(
+ &self,
+ name: &str,
+ schema: &SettingSchema,
+ ) -> Option<JsonValue> {
+ if let Some(value) = self.request_overrides.get(name) {
+ return Some(value.clone());
+ }
+ if let Some(value) = self.session_overrides.get(name) {
+ return Some(value.clone());
+ }
+ if let Some(value) = self.global.get(name) {
+ return Some(value.clone());
+ }
+ schema.default_value.clone()
+ }
+
+ /// Clear all request-level overrides.
+ pub fn clear_request_overrides(&mut self) {
+ self.request_overrides.clear();
+ }
+}
+
+/// Registry of all overridable settings with their schemas.
+#[derive(Debug, Clone)]
+pub struct SettingSchemaRegistry {
+ schemas: BTreeMap<String, SettingSchema>,
+}
+
+impl SettingSchemaRegistry {
+ /// Create a new settings schema registry.
+ pub fn new() -> Self {
+ Self {
+ schemas: BTreeMap::new(),
+ }
+ }
+
+ /// Register a setting schema.
+ pub fn register(&mut self, schema: SettingSchema) {
+ self.schemas.insert(schema.name.clone(), schema);
+ }
+
+ /// Get a schema by name.
+ pub fn get(&self, name: &str) -> Option<&SettingSchema> {
+ self.schemas.get(name)
+ }
+
+ /// Get all schemas.
+ pub fn all(&self) -> impl Iterator<Item = &SettingSchema> {
+ self.schemas.values()
+ }
+
+ /// Get schemas for a specific category.
+ pub fn by_category(&self, category: SettingCategory) -> Vec<&SettingSchema> {
+ self.schemas
+ .values()
+ .filter(|s| s.category == category)
+ .collect()
+ }
+
+ /// Validate a settings object against the registry.
+ pub fn validate(&self, settings: &BTreeMap<String, JsonValue>) -> Result<(), Vec<String>> {
+ let mut errors = Vec::new();
+ for (name, value) in settings {
+ if let Some(schema) = self.get(name) {
+ if !schema.overridable {
+ errors.push(format!("Setting '{}' is not overridable", name));
+ } else if let Err(e) = schema.validate(value) {
+ errors.push(e);
+ }
+ } else {
+ errors.push(format!("Unknown setting: '{}'", name));
+ }
+ }
+ if errors.is_empty() {
+ Ok(())
+ } else {
+ Err(errors)
+ }
+ }
+
+ /// Count total number of registered settings.
+ pub fn len(&self) -> usize {
+ self.schemas.len()
+ }
+
+ /// Check if the registry is empty.
+ pub fn is_empty(&self) -> bool {
+ self.schemas.is_empty()
+ }
+}
+
+impl Default for SettingSchemaRegistry {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+/// Applies and merges settings from multiple sources.
+pub struct SettingApplicator {
+ registry: Arc<Mutex<SettingSchemaRegistry>>,
+ settings: Arc<Mutex<SessionSettings>>,
+}
+
+impl SettingApplicator {
+ /// Create a new setting applicator.
+ pub fn new(registry: SettingSchemaRegistry) -> Self {
+ Self {
+ registry: Arc::new(Mutex::new(registry)),
+ settings: Arc::new(Mutex::new(SessionSettings::new())),
+ }
+ }
+
+ /// Apply global settings.
+ pub fn apply_global(&self, settings: BTreeMap<String, JsonValue>) -> Result<(), Vec<String>> {
+ let registry = self.registry.lock().unwrap();
+ registry.validate(&settings)?;
+ let mut s = self.settings.lock().unwrap();
+ s.global = settings;
+ Ok(())
+ }
+
+ /// Apply session-level overrides.
+ pub fn apply_session_overrides(
+ &self,
+ overrides: BTreeMap<String, JsonValue>,
+ ) -> Result<(), Vec<String>> {
+ let registry = self.registry.lock().unwrap();
+ registry.validate(&overrides)?;
+ let mut s = self.settings.lock().unwrap();
+ s.session_overrides = overrides;
+ Ok(())
+ }
+
+ /// Apply request-level overrides.
+ pub fn apply_request_overrides(
+ &self,
+ overrides: BTreeMap<String, JsonValue>,
+ ) -> Result<(), Vec<String>> {
+ let registry = self.registry.lock().unwrap();
+ registry.validate(&overrides)?;
+ let mut s = self.settings.lock().unwrap();
+ s.request_overrides = overrides;
+ Ok(())
+ }
+
+ /// Get the effective value for a setting.
+ pub fn get_effective(&self, name: &str) -> Option<JsonValue> {
+ let registry = self.registry.lock().unwrap();
+ if let Some(schema) = registry.get(name) {
+ let settings = self.settings.lock().unwrap();
+ settings.get_effective(name, schema)
+ } else {
+ None
+ }
+ }
+
+ /// Get all effective settings.
+ pub fn get_all_effective(&self) -> BTreeMap<String, JsonValue> {
+ let mut result = BTreeMap::new();
+ let registry = self.registry.lock().unwrap();
+ let settings = self.settings.lock().unwrap();
+
+ for schema in registry.all() {
+ if let Some(value) = settings.get_effective(&schema.name, schema) {
+ result.insert(schema.name.clone(), value);
+ }
+ }
+
+ result
+ }
+
+ /// Clear all request-level overrides.
+ pub fn clear_request_overrides(&self) {
+ let mut s = self.settings.lock().unwrap();
+ s.clear_request_overrides();
+ }
+
+ /// Get a clone of the current settings.
+ pub fn get_settings(&self) -> SessionSettings {
+ self.settings.lock().unwrap().clone()
+ }
+}
+
+/// Configuration hotreload monitor that watches for file changes.
+pub struct ConfigHotreloadMonitor {
+ watched_file: PathBuf,
+ last_modified: Arc<Mutex<Option<SystemTime>>>,
+}
+
+impl ConfigHotreloadMonitor {
+ /// Create a new hotreload monitor for a config file.
+ pub fn new(path: impl AsRef<Path>) -> Self {
+ let path = path.as_ref().to_path_buf();
+ let last_modified = fs::metadata(&path)
+ .ok()
+ .and_then(|m| m.modified().ok());
+
+ Self {
+ watched_file: path,
+ last_modified: Arc::new(Mutex::new(last_modified)),
+ }
+ }
+
+ /// Check if the watched file has been modified.
+ pub fn has_changed(&self) -> bool {
+ if let Ok(metadata) = fs::metadata(&self.watched_file) {
+ if let Ok(modified) = metadata.modified() {
+ let mut last = self.last_modified.lock().unwrap();
+ if let Some(prev_modified) = *last {
+ if modified > prev_modified {
+ *last = Some(modified);
+ return true;
+ }
+ }
+ *last = Some(modified);
+ }
+ }
+ false
+ }
+
+ /// Get the modification time of the watched file.
+ pub fn get_modified_time(&self) -> Option<u64> {
+ fs::metadata(&self.watched_file)
+ .ok()
+ .and_then(|m| m.modified().ok())
+ .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
+ .map(|d| d.as_secs())
+ }
+}
+
+fn value_type_label(value: &JsonValue) -> &'static str {
+ match value {
+ JsonValue::String(_) => "string",
+ JsonValue::Number(_) => "number",
+ JsonValue::Bool(_) => "boolean",
+ JsonValue::Array(_) => "array",
+ JsonValue::Object(_) => "object",
+ JsonValue::Null => "null",
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn setting_schema_creation() {
+ let schema = SettingSchema::new(
+ "test_setting",
+ "A test setting",
+ SettingType::String,
+ SettingCategory::Model,
+ );
+
+ assert_eq!(schema.name, "test_setting");
+ assert_eq!(schema.value_type, SettingType::String);
+ assert_eq!(schema.category, SettingCategory::Model);
+ assert!(schema.overridable);
+ }
+
+ #[test]
+ fn setting_schema_validation() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ );
+
+ let valid = JsonValue::String("claude-3-opus".to_string());
+ assert!(schema.validate(&valid).is_ok());
+
+ let invalid = JsonValue::Number(42);
+ assert!(schema.validate(&invalid).is_err());
+ }
+
+ #[test]
+ fn setting_schema_allowed_values() {
+ let schema = SettingSchema::new(
+ "mode",
+ "Permission mode",
+ SettingType::String,
+ SettingCategory::Behavior,
+ )
+ .with_allowed_values(vec![
+ JsonValue::String("read_only".to_string()),
+ JsonValue::String("danger_full_access".to_string()),
+ ]);
+
+ let valid = JsonValue::String("read_only".to_string());
+ assert!(schema.validate(&valid).is_ok());
+
+ let invalid = JsonValue::String("invalid_mode".to_string());
+ assert!(schema.validate(&invalid).is_err());
+ }
+
+ #[test]
+ fn session_settings_hierarchy() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ )
+ .with_default(JsonValue::String("claude-3-haiku".to_string()));
+
+ let mut settings = SessionSettings::new();
+ settings.set_global("model", JsonValue::String("claude-3-sonnet".to_string()));
+ settings.set_session_override("model", JsonValue::String("claude-3-opus".to_string()));
+
+ let effective = settings.get_effective("model", &schema);
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-opus".to_string()))
+ );
+
+ settings.clear_request_overrides();
+ let effective = settings.get_effective("model", &schema);
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-opus".to_string()))
+ );
+ }
+
+ #[test]
+ fn session_settings_request_override_precedence() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ )
+ .with_default(JsonValue::String("claude-3-haiku".to_string()));
+
+ let mut settings = SessionSettings::new();
+ settings.set_global("model", JsonValue::String("claude-3-sonnet".to_string()));
+ settings.set_session_override("model", JsonValue::String("claude-3-opus".to_string()));
+ settings.set_request_override("model", JsonValue::String("claude-3-opus-200k".to_string()));
+
+ let effective = settings.get_effective("model", &schema);
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-opus-200k".to_string()))
+ );
+ }
+
+ #[test]
+ fn registry_registration_and_retrieval() {
+ let mut registry = SettingSchemaRegistry::new();
+
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ );
+
+ registry.register(schema.clone());
+
+ assert_eq!(registry.get("model"), Some(&schema));
+ assert!(registry.get("nonexistent").is_none());
+ assert_eq!(registry.len(), 1);
+ }
+
+ #[test]
+ fn registry_validation() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let mut settings = BTreeMap::new();
+ settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+
+ assert!(registry.validate(&settings).is_ok());
+ }
+
+ #[test]
+ fn registry_validation_invalid_type() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let mut settings = BTreeMap::new();
+ settings.insert("model".to_string(), JsonValue::Number(42));
+
+ assert!(registry.validate(&settings).is_err());
+ }
+
+ #[test]
+ fn registry_validation_unknown_setting() {
+ let registry = SettingSchemaRegistry::new();
+
+ let mut settings = BTreeMap::new();
+ settings.insert(
+ "unknown".to_string(),
+ JsonValue::String("value".to_string()),
+ );
+
+ assert!(registry.validate(&settings).is_err());
+ }
+
+ #[test]
+ fn setting_applicator_apply_global() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut settings = BTreeMap::new();
+ settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+
+ assert!(applicator.apply_global(settings).is_ok());
+
+ let effective = applicator.get_effective("model");
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-opus".to_string()))
+ );
+ }
+
+ #[test]
+ fn setting_applicator_override_hierarchy() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ );
+ applicator.apply_global(global_settings).unwrap();
+
+ let mut session_overrides = BTreeMap::new();
+ session_overrides.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+ applicator.apply_session_overrides(session_overrides).unwrap();
+
+ let effective = applicator.get_effective("model");
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-opus".to_string()))
+ );
+ }
+
+ #[test]
+ fn setting_applicator_clear_request_overrides() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ );
+ applicator.apply_global(global_settings).unwrap();
+
+ let mut request_overrides = BTreeMap::new();
+ request_overrides.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+ applicator.apply_request_overrides(request_overrides).unwrap();
+
+ applicator.clear_request_overrides();
+
+ let effective = applicator.get_effective("model");
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-sonnet".to_string()))
+ );
+ }
+
+ #[test]
+ fn registry_by_category() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+ registry.register(
+ SettingSchema::new(
+ "temperature",
+ "Sampling temperature",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ let model_settings = registry.by_category(SettingCategory::Model);
+ assert_eq!(model_settings.len(), 1);
+
+ let advanced_settings = registry.by_category(SettingCategory::Advanced);
+ assert_eq!(advanced_settings.len(), 1);
+ }
+
+ #[test]
+ fn hotreload_monitor_creation() {
+ // Create a temporary file for testing
+ let temp_file = std::env::temp_dir().join("test_config.json");
+ fs::write(&temp_file, "{}").unwrap();
+
+ let monitor = ConfigHotreloadMonitor::new(&temp_file);
+ assert!(monitor.get_modified_time().is_some());
+
+ fs::remove_file(temp_file).ok();
+ }
+
+ #[test]
+ fn permission_mode_override_per_session() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "permission_mode",
+ "Permission mode for the session",
+ SettingType::String,
+ SettingCategory::Behavior,
+ )
+ .with_allowed_values(vec![
+ JsonValue::String("read_only".to_string()),
+ JsonValue::String("workspace_write".to_string()),
+ JsonValue::String("danger_full_access".to_string()),
+ ]),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "permission_mode".to_string(),
+ JsonValue::String("read_only".to_string()),
+ );
+ assert!(applicator.apply_global(global_settings).is_ok());
+
+ let mut session_overrides = BTreeMap::new();
+ session_overrides.insert(
+ "permission_mode".to_string(),
+ JsonValue::String("workspace_write".to_string()),
+ );
+ assert!(applicator.apply_session_overrides(session_overrides).is_ok());
+
+ let effective = applicator.get_effective("permission_mode");
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("workspace_write".to_string()))
+ );
+ }
+
+ #[test]
+ fn temperature_token_overrides_work() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "temperature",
+ "Sampling temperature",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+ registry.register(
+ SettingSchema::new(
+ "max_tokens",
+ "Maximum tokens to generate",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert("temperature".to_string(), JsonValue::Number(7));
+ global_settings.insert("max_tokens".to_string(), JsonValue::Number(4096));
+ assert!(applicator.apply_global(global_settings).is_ok());
+
+ let mut session_overrides = BTreeMap::new();
+ session_overrides.insert("temperature".to_string(), JsonValue::Number(5));
+ assert!(applicator.apply_session_overrides(session_overrides).is_ok());
+
+ assert_eq!(applicator.get_effective("temperature"), Some(JsonValue::Number(5)));
+ assert_eq!(
+ applicator.get_effective("max_tokens"),
+ Some(JsonValue::Number(4096))
+ );
+ }
+
+ #[test]
+ fn setting_propagation_to_all_tools() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+ registry.register(
+ SettingSchema::new(
+ "context_window",
+ "Context window size",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ );
+ global_settings.insert("context_window".to_string(), JsonValue::Number(200000));
+ assert!(applicator.apply_global(global_settings).is_ok());
+
+ let all_effective = applicator.get_all_effective();
+ assert_eq!(all_effective.len(), 2);
+ assert_eq!(
+ all_effective.get("model"),
+ Some(&JsonValue::String("claude-3-sonnet".to_string()))
+ );
+ assert_eq!(
+ all_effective.get("context_window"),
+ Some(&JsonValue::Number(200000))
+ );
+ }
+
+ #[test]
+ fn setting_default_values() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ )
+ .with_default(JsonValue::String("claude-3-haiku".to_string()));
+
+ let settings = SessionSettings::new();
+ let effective = settings.get_effective("model", &schema);
+ assert_eq!(
+ effective,
+ Some(JsonValue::String("claude-3-haiku".to_string()))
+ );
+ }
+
+ #[test]
+ fn setting_non_overridable() {
+ let mut registry = SettingSchemaRegistry::new();
+ let schema = SettingSchema::new(
+ "system_prompt",
+ "System prompt",
+ SettingType::String,
+ SettingCategory::Advanced,
+ )
+ .with_overridable(false);
+
+ registry.register(schema);
+
+ let mut settings = BTreeMap::new();
+ settings.insert(
+ "system_prompt".to_string(),
+ JsonValue::String("custom prompt".to_string()),
+ );
+
+ assert!(registry.validate(&settings).is_err());
+ }
+
+ #[test]
+ fn applicator_validation_error_on_invalid_override() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut invalid_overrides = BTreeMap::new();
+ invalid_overrides.insert("model".to_string(), JsonValue::Number(42));
+
+ let result = applicator.apply_session_overrides(invalid_overrides);
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn registry_len_and_is_empty() {
+ let mut registry = SettingSchemaRegistry::new();
+ assert!(registry.is_empty());
+ assert_eq!(registry.len(), 0);
+
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ assert!(!registry.is_empty());
+ assert_eq!(registry.len(), 1);
+ }
+
+ #[test]
+ fn dynamic_setting_application_mid_session() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ // Apply initial settings
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ );
+ applicator.apply_global(global_settings).unwrap();
+
+ // Override mid-session
+ let mut overrides = BTreeMap::new();
+ overrides.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+ applicator.apply_request_overrides(overrides).unwrap();
+
+ assert_eq!(
+ applicator.get_effective("model"),
+ Some(JsonValue::String("claude-3-opus".to_string()))
+ );
+
+ // Change override again
+ let mut new_overrides = BTreeMap::new();
+ new_overrides.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-haiku".to_string()),
+ );
+ applicator.apply_request_overrides(new_overrides).unwrap();
+
+ assert_eq!(
+ applicator.get_effective("model"),
+ Some(JsonValue::String("claude-3-haiku".to_string()))
+ );
+ }
+
+ #[test]
+ fn config_hotreload_has_changed() {
+ let temp_file = std::env::temp_dir().join("test_hotreload.json");
+ fs::write(&temp_file, r#"{"model":"claude-3-sonnet"}"#).unwrap();
+
+ let monitor = ConfigHotreloadMonitor::new(&temp_file);
+
+ // First check should not detect change
+ assert!(!monitor.has_changed());
+
+ // Modify the file
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ fs::write(&temp_file, r#"{"model":"claude-3-opus"}"#).unwrap();
+
+ // Second check should detect change
+ assert!(monitor.has_changed());
+
+ // Third check should not detect change (already recorded)
+ assert!(!monitor.has_changed());
+
+ fs::remove_file(temp_file).ok();
+ }
+
+ #[test]
+ fn merge_global_session_request_hierarchy() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ )
+ .with_default(JsonValue::String("claude-3-haiku".to_string())),
+ );
+ registry.register(
+ SettingSchema::new(
+ "temperature",
+ "Sampling temperature",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ );
+ global_settings.insert("temperature".to_string(), JsonValue::Number(8));
+ applicator.apply_global(global_settings).unwrap();
+
+ let mut session_overrides = BTreeMap::new();
+ session_overrides.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+ applicator.apply_session_overrides(session_overrides).unwrap();
+
+ let mut request_overrides = BTreeMap::new();
+ request_overrides.insert("temperature".to_string(), JsonValue::Number(6));
+ applicator.apply_request_overrides(request_overrides).unwrap();
+
+ // model should use session override
+ assert_eq!(
+ applicator.get_effective("model"),
+ Some(JsonValue::String("claude-3-opus".to_string()))
+ );
+
+ // temperature should use request override
+ assert_eq!(
+ applicator.get_effective("temperature"),
+ Some(JsonValue::Number(6))
+ );
+ }
+
+ #[test]
+ fn setting_schema_with_builder_pattern() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ )
+ .with_default(JsonValue::String("claude-3-sonnet".to_string()))
+ .with_overridable(true)
+ .with_allowed_values(vec![
+ JsonValue::String("claude-3-haiku".to_string()),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ JsonValue::String("claude-3-opus".to_string()),
+ ]);
+
+ assert!(schema.validate(&JsonValue::String("claude-3-opus".to_string())).is_ok());
+ assert!(schema
+ .validate(&JsonValue::String("invalid-model".to_string()))
+ .is_err());
+ }
+
+ #[test]
+ fn get_settings_clone() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut global_settings = BTreeMap::new();
+ global_settings.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-opus".to_string()),
+ );
+ applicator.apply_global(global_settings).unwrap();
+
+ let mut session_overrides = BTreeMap::new();
+ session_overrides.insert(
+ "model".to_string(),
+ JsonValue::String("claude-3-sonnet".to_string()),
+ );
+ applicator.apply_session_overrides(session_overrides).unwrap();
+
+ let settings = applicator.get_settings();
+ assert_eq!(settings.global.len(), 1);
+ assert_eq!(settings.session_overrides.len(), 1);
+ }
+
+ #[test]
+ fn multiple_settings_per_category() {
+ let mut registry = SettingSchemaRegistry::new();
+
+ // Model settings
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+
+ // Behavior settings
+ registry.register(
+ SettingSchema::new(
+ "permission_mode",
+ "Permission mode",
+ SettingType::String,
+ SettingCategory::Behavior,
+ ),
+ );
+ registry.register(
+ SettingSchema::new(
+ "auto_save",
+ "Enable auto-save",
+ SettingType::Boolean,
+ SettingCategory::Behavior,
+ ),
+ );
+
+ // UX settings
+ registry.register(
+ SettingSchema::new(
+ "verbose_output",
+ "Enable verbose output",
+ SettingType::Boolean,
+ SettingCategory::Ux,
+ ),
+ );
+
+ // Advanced settings
+ registry.register(
+ SettingSchema::new(
+ "temperature",
+ "Sampling temperature",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ assert_eq!(registry.by_category(SettingCategory::Model).len(), 1);
+ assert_eq!(registry.by_category(SettingCategory::Behavior).len(), 2);
+ assert_eq!(registry.by_category(SettingCategory::Ux).len(), 1);
+ assert_eq!(registry.by_category(SettingCategory::Advanced).len(), 1);
+ assert_eq!(registry.len(), 5);
+ }
+
+ #[test]
+ fn setting_with_no_default() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ );
+
+ let settings = SessionSettings::new();
+ let effective = settings.get_effective("model", &schema);
+ assert_eq!(effective, None);
+ }
+
+ #[test]
+ fn setting_category_display() {
+ assert_eq!(SettingCategory::Model.to_string(), "model");
+ assert_eq!(SettingCategory::Behavior.to_string(), "behavior");
+ assert_eq!(SettingCategory::Ux.to_string(), "ux");
+ assert_eq!(SettingCategory::Advanced.to_string(), "advanced");
+ }
+
+ #[test]
+ fn setting_type_display() {
+ assert_eq!(SettingType::String.to_string(), "string");
+ assert_eq!(SettingType::Number.to_string(), "number");
+ assert_eq!(SettingType::Boolean.to_string(), "boolean");
+ assert_eq!(SettingType::Object.to_string(), "object");
+ }
+
+ #[test]
+ fn setting_validation_error_message() {
+ let schema = SettingSchema::new(
+ "model",
+ "The model to use",
+ SettingType::String,
+ SettingCategory::Model,
+ );
+
+ let invalid = JsonValue::Number(42);
+ let result = schema.validate(&invalid);
+ assert!(result.is_err());
+ let err = result.unwrap_err();
+ assert!(err.contains("model"));
+ assert!(err.contains("string"));
+ }
+
+ #[test]
+ fn allowed_values_validation_error() {
+ let schema = SettingSchema::new(
+ "mode",
+ "Permission mode",
+ SettingType::String,
+ SettingCategory::Behavior,
+ )
+ .with_allowed_values(vec![
+ JsonValue::String("read_only".to_string()),
+ JsonValue::String("danger_full_access".to_string()),
+ ]);
+
+ let invalid = JsonValue::String("invalid_mode".to_string());
+ let result = schema.validate(&invalid);
+ assert!(result.is_err());
+ let err = result.unwrap_err();
+ assert!(err.contains("mode"));
+ }
+
+ #[test]
+ fn session_settings_clear_preserves_global_and_session() {
+ let mut settings = SessionSettings::new();
+ settings.set_global("model", JsonValue::String("sonnet".to_string()));
+ settings.set_session_override("model", JsonValue::String("opus".to_string()));
+ settings.set_request_override("model", JsonValue::String("haiku".to_string()));
+
+ settings.clear_request_overrides();
+
+ assert_eq!(settings.global.len(), 1);
+ assert_eq!(settings.session_overrides.len(), 1);
+ assert_eq!(settings.request_overrides.len(), 0);
+ }
+
+ #[test]
+ fn object_type_setting() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "custom_config",
+ "Custom configuration object",
+ SettingType::Object,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut config_obj = BTreeMap::new();
+ config_obj.insert("nested".to_string(), JsonValue::String("value".to_string()));
+
+ let mut settings = BTreeMap::new();
+ settings.insert("custom_config".to_string(), JsonValue::Object(config_obj));
+
+ assert!(applicator.apply_global(settings).is_ok());
+ assert!(applicator.get_effective("custom_config").is_some());
+ }
+
+ #[test]
+ fn boolean_type_setting() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "verbose",
+ "Enable verbose output",
+ SettingType::Boolean,
+ SettingCategory::Ux,
+ ),
+ );
+
+ let applicator = SettingApplicator::new(registry);
+
+ let mut settings = BTreeMap::new();
+ settings.insert("verbose".to_string(), JsonValue::Bool(true));
+
+ assert!(applicator.apply_global(settings).is_ok());
+ assert_eq!(applicator.get_effective("verbose"), Some(JsonValue::Bool(true)));
+ }
+
+ #[test]
+ fn registry_all_returns_all_schemas() {
+ let mut registry = SettingSchemaRegistry::new();
+ registry.register(
+ SettingSchema::new(
+ "model",
+ "The model",
+ SettingType::String,
+ SettingCategory::Model,
+ ),
+ );
+ registry.register(
+ SettingSchema::new(
+ "temperature",
+ "Temperature",
+ SettingType::Number,
+ SettingCategory::Advanced,
+ ),
+ );
+
+ let all: Vec<_> = registry.all().collect();
+ assert_eq!(all.len(), 2);
+ }
+}