From fa1bd32800b65aab31ea732dd240261b4047522c Mon Sep 17 00:00:00 2001
From: main <main@swarm.moe>
Date: Thu, 19 Mar 2026 15:49:41 -0400
Subject: Release adequate-rust-mcp 1.0.0

---
 crates/ra-mcp-engine/src/config.rs | 79 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 crates/ra-mcp-engine/src/config.rs

(limited to 'crates/ra-mcp-engine/src/config.rs')

diff --git a/crates/ra-mcp-engine/src/config.rs b/crates/ra-mcp-engine/src/config.rs
new file mode 100644
index 0000000..8d116d5
--- /dev/null
+++ b/crates/ra-mcp-engine/src/config.rs
@@ -0,0 +1,79 @@
+use ra_mcp_domain::types::{InvariantViolation, WorkspaceRoot};
+use std::{path::PathBuf, time::Duration};
+
+/// Exponential backoff policy for worker restart attempts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct BackoffPolicy {
+    /// Minimum delay between restart attempts.
+    pub floor: Duration,
+    /// Maximum delay between restart attempts.
+    pub ceiling: Duration,
+}
+
+impl BackoffPolicy {
+    /// Builds a validated backoff policy.
+    pub fn try_new(floor: Duration, ceiling: Duration) -> Result<Self, InvariantViolation> {
+        if floor.is_zero() {
+            return Err(InvariantViolation::new("backoff floor must be non-zero"));
+        }
+        if ceiling < floor {
+            return Err(InvariantViolation::new(
+                "backoff ceiling must be greater than or equal to floor",
+            ));
+        }
+        Ok(Self { floor, ceiling })
+    }
+}
+
+/// Runtime engine configuration.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EngineConfig {
+    /// Absolute workspace root used for rust-analyzer process cwd/root URI.
+    pub workspace_root: WorkspaceRoot,
+    /// rust-analyzer executable path.
+    pub rust_analyzer_binary: PathBuf,
+    /// Additional rust-analyzer process arguments.
+    pub rust_analyzer_args: Vec<String>,
+    /// Additional rust-analyzer process environment variables.
+    pub rust_analyzer_env: Vec<(String, String)>,
+    /// Startup handshake timeout.
+    pub startup_timeout: Duration,
+    /// Timeout for ordinary requests.
+    pub request_timeout: Duration,
+    /// Restart backoff policy.
+    pub backoff_policy: BackoffPolicy,
+}
+
+impl EngineConfig {
+    /// Builds validated engine configuration.
+    pub fn try_new(
+        workspace_root: WorkspaceRoot,
+        rust_analyzer_binary: PathBuf,
+        rust_analyzer_args: Vec<String>,
+        rust_analyzer_env: Vec<(String, String)>,
+        startup_timeout: Duration,
+        request_timeout: Duration,
+        backoff_policy: BackoffPolicy,
+    ) -> Result<Self, InvariantViolation> {
+        if rust_analyzer_binary.as_os_str().is_empty() {
+            return Err(InvariantViolation::new(
+                "rust-analyzer binary path must be non-empty",
+            ));
+        }
+        if startup_timeout.is_zero() {
+            return Err(InvariantViolation::new("startup timeout must be non-zero"));
+        }
+        if request_timeout.is_zero() {
+            return Err(InvariantViolation::new("request timeout must be non-zero"));
+        }
+        Ok(Self {
+            workspace_root,
+            rust_analyzer_binary,
+            rust_analyzer_args,
+            rust_analyzer_env,
+            startup_timeout,
+            request_timeout,
+            backoff_policy,
+        })
+    }
+}
-- 
cgit v1.2.3