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.rsindex 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.rsnew file mode 100644index 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);+ }+}