chore: fmt

Author: josh-tracey

rain-engine-core/src/engine.rs

@@ -304,7 +304,7 @@ impl AgentEngine {
                         wake_request: None,
                     });
                 }
-            }
+            },
         };
         counter!("rain_engine.triggers_total").increment(1);
 
@@ -1663,22 +1663,26 @@ impl AgentEngine {
             warn!(session_id = %context.session_id, "failed to record outcome: {}", err.message);
         }
 
-        context.records.push(SessionRecord::Outcome(outcome.clone()));
+        context
+            .records
+            .push(SessionRecord::Outcome(outcome.clone()));
 
         let outcome_clone = outcome.clone();
-        self.run_self_improvement(context, outcome_clone)
-            .await?;
+        self.run_self_improvement(context, outcome_clone).await?;
 
         // Update the state projection cache AFTER self improvement
-        let _ = self.state_cache.set_projection(
-            &context.session_id,
-            SessionSnapshot {
-                session_id: context.session_id.clone(),
-                records: context.records.clone(),
-                last_sequence_no: None,
-                latest_outcome: Some(outcome.clone()),
-            }
-        ).await;
+        let _ = self
+            .state_cache
+            .set_projection(
+                &context.session_id,
+                SessionSnapshot {
+                    session_id: context.session_id.clone(),
+                    records: context.records.clone(),
+                    last_sequence_no: None,
+                    latest_outcome: Some(outcome.clone()),
+                },
+            )
+            .await;
 
         Ok(EngineOutcome {
             trigger_id: outcome.trigger_id,
@@ -1734,7 +1738,9 @@ impl AgentEngine {
             self.memory
                 .append_tool_performance(&session_id, performance.clone())
                 .await?;
-            context.records.push(SessionRecord::ToolPerformance(performance.clone()));
+            context
+                .records
+                .push(SessionRecord::ToolPerformance(performance.clone()));
 
             if performance.calls > 0 {
                 counter!(
@@ -1759,7 +1765,9 @@ impl AgentEngine {
                 self.memory
                     .append_strategy_preference(&session_id, preference.clone())
                     .await?;
-                context.records.push(SessionRecord::StrategyPreference(preference));
+                context
+                    .records
+                    .push(SessionRecord::StrategyPreference(preference));
             }
         }
 
@@ -1804,7 +1812,9 @@ impl AgentEngine {
         self.memory
             .append_profile_patch(&session_id, profile_patch.clone())
             .await?;
-        context.records.push(SessionRecord::ProfilePatch(profile_patch));
+        context
+            .records
+            .push(SessionRecord::ProfilePatch(profile_patch));
 
         Ok(())
     }
@@ -2045,9 +2055,7 @@ fn maybe_rollback_regression(
     // is progress, not a failure of the policy overlay itself.
     if !matches!(
         outcome.stop_reason,
-        StopReason::ProviderFailure
-            | StopReason::DeadlineExceeded
-            | StopReason::PolicyAborted
+        StopReason::ProviderFailure | StopReason::DeadlineExceeded | StopReason::PolicyAborted
     ) {
         return None;
     }
@@ -2108,7 +2116,10 @@ fn propose_policy_tuning(
             // We use the terminal observation count as a multiplier
             let multiplier = terminal_observation_count(&snapshot.history).max(1) as f64;
             let aggressive_delta = (delta * multiplier).min(200.0); // Cap at 200% increase per try
-            patch.max_steps = Some(increase_usize_by_percent(snapshot.policy.max_steps, aggressive_delta));
+            patch.max_steps = Some(increase_usize_by_percent(
+                snapshot.policy.max_steps,
+                aggressive_delta,
+            ));
             reason = Some(
                 "Session hit max steps; increasing future step budget within guardrails."
                     .to_string(),
@@ -2167,7 +2178,7 @@ fn propose_policy_tuning(
             SelfImprovementMode::Shadow => {
                 overlay.status = PolicyOverlayStatus::Proposed; // Start as proposed in shadow mode
                 PolicyTuningAction::Proposed
-            },
+            }
             SelfImprovementMode::AutoWithGuardrails => PolicyTuningAction::Applied,
         }
     };

rain-engine-core/src/state_cache.rs

@@ -71,8 +71,8 @@ impl StateProjectionCache for ValkeyStateCache {
 
         match val {
             Some(bytes) => {
-                let snapshot =
-                    serde_json::from_slice(&bytes).map_err(|e| format!("De-serialize error: {}", e))?;
+                let snapshot = serde_json::from_slice(&bytes)
+                    .map_err(|e| format!("De-serialize error: {}", e))?;
                 Ok(Some(snapshot))
             }
             None => Ok(None),

rain-engine-core/src/traits.rs

@@ -38,7 +38,14 @@ pub trait SkillStore: Send + Sync {
 
 #[async_trait]
 pub trait StateProjectionCache: Send + Sync {
-    async fn get_projection(&self, session_id: &str) -> Result<Option<crate::SessionSnapshot>, String>;
-    async fn set_projection(&self, session_id: &str, snapshot: crate::SessionSnapshot) -> Result<(), String>;
+    async fn get_projection(
+        &self,
+        session_id: &str,
+    ) -> Result<Option<crate::SessionSnapshot>, String>;
+    async fn set_projection(
+        &self,
+        session_id: &str,
+        snapshot: crate::SessionSnapshot,
+    ) -> Result<(), String>;
     async fn invalidate(&self, session_id: &str) -> Result<(), String>;
 }

rain-engine-gateway/src/main.rs

@@ -146,17 +146,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // ---------------------------------------------------------------------------
     // Build the HTTP router with CORS
     // ---------------------------------------------------------------------------
-    let cors_base = CorsLayer::new()
-        .allow_methods(Any)
-        .allow_headers(Any);
-        
+    let cors_base = CorsLayer::new().allow_methods(Any).allow_headers(Any);
+
     let cors = if let Ok(origins) = env::var("RAIN_CORS_ALLOWED_ORIGINS") {
         if origins == "*" {
             cors_base.allow_origin(Any)
         } else {
-            // To simplify for the gateway, if a specific list is provided, 
-            // we'll just use the first one exactly, or require a more complex CORS layer 
-            // for multiple. For now, since tower-http's AllowOrigin::list takes an array 
+            // To simplify for the gateway, if a specific list is provided,
+            // we'll just use the first one exactly, or require a more complex CORS layer
+            // for multiple. For now, since tower-http's AllowOrigin::list takes an array
             // and is hard to build dynamically, we'll allow Any if they set origins dynamically
             // but log a warning. A proper production setup would use a custom origin closure.
             // Let's implement it the simplest secure way: if it's set to a specific single domain, use that.

rain-engine-runtime/src/lib.rs

@@ -200,7 +200,10 @@ impl NativeSkill for SkillInstallerSkill {
         let file_path = invocation.args.get("file_path").and_then(|v| v.as_str());
 
         if wasm_url.is_none() && wasm_base64.is_none() && file_path.is_none() {
-            return Err(SkillExecutionError::new(SkillFailureKind::InvalidArguments, "missing wasm_url, wasm_base64, or file_path"));
+            return Err(SkillExecutionError::new(
+                SkillFailureKind::InvalidArguments,
+                "missing wasm_url, wasm_base64, or file_path",
+            ));
         }
 
         let input_schema = invocation
@@ -252,14 +255,23 @@ impl NativeSkill for SkillInstallerSkill {
         } else if let Some(b64) = wasm_base64 {
             use base64::{Engine as _, engine::general_purpose};
             general_purpose::STANDARD.decode(b64).map_err(|err| {
-                SkillExecutionError::new(SkillFailureKind::InvalidArguments, format!("Base64 decode failed: {}", err))
+                SkillExecutionError::new(
+                    SkillFailureKind::InvalidArguments,
+                    format!("Base64 decode failed: {}", err),
+                )
             })?
         } else if let Some(path) = file_path {
             tokio::fs::read(path).await.map_err(|err| {
-                SkillExecutionError::new(SkillFailureKind::InvalidArguments, format!("File read failed: {}", err))
+                SkillExecutionError::new(
+                    SkillFailureKind::InvalidArguments,
+                    format!("File read failed: {}", err),
+                )
             })?
         } else {
-            return Err(SkillExecutionError::new(SkillFailureKind::InvalidArguments, "missing wasm_url, wasm_base64, or file_path"));
+            return Err(SkillExecutionError::new(
+                SkillFailureKind::InvalidArguments,
+                "missing wasm_url, wasm_base64, or file_path",
+            ));
         };
 
         let config = rain_engine_wasm::WasmSkillConfig {
@@ -736,11 +748,13 @@ pub async fn build_runtime_state(
     };
 
     let mut engine = AgentEngine::new(llm.clone(), memory.clone());
-    
+
     if let Some(cache_config) = &config.cache {
         if let Some(valkey_url) = &cache_config.valkey_url {
             let valkey_cache = rain_engine_core::ValkeyStateCache::new(valkey_url, "rain")
-                .map_err(|err| RuntimeConfigError::Invalid(format!("Valkey cache error: {}", err)))?;
+                .map_err(|err| {
+                    RuntimeConfigError::Invalid(format!("Valkey cache error: {}", err))
+                })?;
             engine = engine.with_state_cache(Arc::new(valkey_cache));
             tracing::info!("Configured Valkey state projection cache");
         }
@@ -1331,47 +1345,50 @@ async fn handle_get_session(
     State(state): State<RuntimeState>,
     Path(session_id): Path<String>,
 ) -> Result<Json<Value>, (StatusCode, String)> {
-    let snapshot = if let Ok(Some(cached)) = state.engine.state_cache().get_projection(&session_id).await {
-        cached
-    } else {
-        state
-            .memory
-            .load_session(&session_id)
-            .await
-            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.message))?
-    };
+    let snapshot =
+        if let Ok(Some(cached)) = state.engine.state_cache().get_projection(&session_id).await {
+            cached
+        } else {
+            state
+                .memory
+                .load_session(&session_id)
+                .await
+                .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.message))?
+        };
     Ok(Json(serde_json::to_value(snapshot).unwrap_or_default()))
 }
 
 async fn handle_get_session_view(
     State(state): State<RuntimeState>,
     Path(session_id): Path<String>,
 ) -> Result<Json<SessionView>, (StatusCode, String)> {
-    let snapshot = if let Ok(Some(cached)) = state.engine.state_cache().get_projection(&session_id).await {
-        cached
-    } else {
-        state
-            .memory
-            .load_session(&session_id)
-            .await
-            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.message))?
-    };
+    let snapshot =
+        if let Ok(Some(cached)) = state.engine.state_cache().get_projection(&session_id).await {
+            cached
+        } else {
+            state
+                .memory
+                .load_session(&session_id)
+                .await
+                .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.message))?
+        };
     Ok(Json(build_session_view(snapshot)))
 }
 
 async fn handle_get_execution_graph(
     State(state): State<RuntimeState>,
     Path(session_id): Path<String>,
 ) -> Result<Json<ExecutionGraphView>, (StatusCode, String)> {
-    let snapshot = if let Ok(Some(cached)) = state.engine.state_cache().get_projection(&session_id).await {
-        cached
-    } else {
-        state
-            .memory
-            .load_session(&session_id)
-            .await
-            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.message))?
-    };
+    let snapshot =
+        if let Ok(Some(cached)) = state.engine.state_cache().get_projection(&session_id).await {
+            cached
+        } else {
+            state
+                .memory
+                .load_session(&session_id)
+                .await
+                .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.message))?
+        };
     Ok(Json(build_execution_graph_view(&snapshot)))
 }
 
@@ -1408,14 +1425,23 @@ async fn handle_install_skill(
     } else if let Some(b64) = &request.wasm_base64 {
         use base64::{Engine as _, engine::general_purpose};
         general_purpose::STANDARD.decode(b64).map_err(|err| {
-            (StatusCode::BAD_REQUEST, format!("Base64 decode failed: {}", err))
+            (
+                StatusCode::BAD_REQUEST,
+                format!("Base64 decode failed: {}", err),
+            )
         })?
     } else if let Some(path) = &request.file_path {
         tokio::fs::read(path).await.map_err(|err| {
-            (StatusCode::BAD_REQUEST, format!("File read failed: {}", err))
+            (
+                StatusCode::BAD_REQUEST,
+                format!("File read failed: {}", err),
+            )
         })?
     } else {
-        return Err((StatusCode::BAD_REQUEST, "Must provide wasm_url, wasm_base64, or file_path".to_string()));
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "Must provide wasm_url, wasm_base64, or file_path".to_string(),
+        ));
     };
 
     let config = rain_engine_wasm::WasmSkillConfig {

src/server.rs

@@ -28,7 +28,7 @@ impl Default for ServerBuilder {
                 },
                 store: StoreBootstrapConfig::InMemory, // Portable by default
                 cache: None,
-                blob: BlobBackendConfig::InMemory,     // Portable by default
+                blob: BlobBackendConfig::InMemory, // Portable by default
                 provider: ProviderBootstrapConfig::Mock {
                     response: "Mock Response".to_string(),
                 },