fix(forge_config): fix f32/f64 TOML serialization noise with Decimal newtype (#2733)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: tusharmath

crates/forge_config/src/compact.rs

@@ -5,6 +5,8 @@ use fake::Dummy;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use crate::Percentage;
+
 /// Frequency at which forge checks for updates
 #[derive(Default, Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, fake::Dummy)]
 #[serde(rename_all = "snake_case")]
@@ -37,21 +39,6 @@ pub struct Update {
     pub auto_update: Option<bool>,
 }
 
-fn deserialize_percentage<'de, D>(deserializer: D) -> Result<f64, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use serde::de::Error;
-
-    let value = f64::deserialize(deserializer)?;
-    if !(0.0..=1.0).contains(&value) {
-        return Err(Error::custom(format!(
-            "percentage must be between 0.0 and 1.0, got {value}"
-        )));
-    }
-    Ok(value)
-}
-
 /// Configuration for automatic context compaction for all agents
 #[derive(Debug, Clone, Serialize, Deserialize, Setters, JsonSchema, PartialEq)]
 #[setters(strip_option, into)]
@@ -68,8 +55,8 @@ pub struct Compact {
     /// compaction and 1.0 allows summarizing all messages. Works alongside
     /// retention_window - the more conservative limit (fewer messages to
     /// compact) takes precedence.
-    #[serde(default, deserialize_with = "deserialize_percentage")]
-    pub eviction_window: f64,
+    #[serde(default)]
+    pub eviction_window: Percentage,
 
     /// Maximum number of tokens to keep after compaction
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -113,7 +100,7 @@ impl Compact {
             turn_threshold: None,
             message_threshold: None,
             model: None,
-            eviction_window: 0.2,
+            eviction_window: Percentage::new(0.2).unwrap(),
             retention_window: 0,
             on_turn_end: None,
         }
@@ -125,7 +112,7 @@ impl Dummy<fake::Faker> for Compact {
         use fake::Fake;
         Self {
             retention_window: fake::Faker.fake_with_rng(rng),
-            eviction_window: (0.0f64..=1.0f64).fake_with_rng(rng),
+            eviction_window: Percentage::from((0.0f64..=1.0f64).fake_with_rng::<f64, R>(rng)),
             max_tokens: fake::Faker.fake_with_rng(rng),
             token_threshold: fake::Faker.fake_with_rng(rng),
             turn_threshold: fake::Faker.fake_with_rng(rng),
@@ -135,3 +122,62 @@ impl Dummy<fake::Faker> for Compact {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+    use crate::reader::ConfigReader;
+
+    #[test]
+    fn test_f64_eviction_window_round_trip() {
+        let fixture = Compact {
+            eviction_window: Percentage::new(0.2).unwrap(),
+            ..Compact::new()
+        };
+
+        let toml = toml_edit::ser::to_string_pretty(&fixture).unwrap();
+
+        assert!(
+            toml.contains("eviction_window = 0.2\n"),
+            "expected `eviction_window = 0.2` in TOML output, got:\n{toml}"
+        );
+    }
+
+    #[test]
+    fn test_f64_eviction_window_deserialize_round_trip() {
+        let fixture = Compact {
+            eviction_window: Percentage::new(0.2).unwrap(),
+            ..Compact::new()
+        };
+
+        let toml = toml_edit::ser::to_string_pretty(&fixture).unwrap();
+
+        let actual = ConfigReader::default()
+            .read_defaults()
+            .read_toml(&toml)
+            .build()
+            .unwrap()
+            .compact
+            .unwrap_or_default();
+
+        assert_eq!(actual.eviction_window, fixture.eviction_window);
+    }
+
+    #[test]
+    fn test_eviction_window_rejects_out_of_range() {
+        let toml = "[compact]\neviction_window = 1.5\n";
+
+        let result = ConfigReader::default()
+            .read_defaults()
+            .read_toml(toml)
+            .build();
+
+        assert!(
+            result.is_err(),
+            "expected error for eviction_window = 1.5, got: {:?}",
+            result.ok()
+        );
+    }
+}

crates/forge_config/src/config.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::reader::ConfigReader;
 use crate::writer::ConfigWriter;
-use crate::{AutoDumpFormat, Compact, HttpConfig, ModelConfig, RetryConfig, Update};
+use crate::{AutoDumpFormat, Compact, Decimal, HttpConfig, ModelConfig, RetryConfig, Update};
 
 /// Top-level Forge configuration merged from all sources (defaults, file,
 /// environment).
@@ -85,12 +85,12 @@ pub struct ForgeConfig {
     /// Output randomness for all agents; lower values are deterministic, higher
     /// values are creative (0.0–2.0).
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
+    pub temperature: Option<Decimal>,
 
     /// Nucleus sampling threshold for all agents; limits token selection to the
     /// top cumulative probability mass (0.0–1.0).
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub top_p: Option<f32>,
+    pub top_p: Option<Decimal>,
 
     /// Top-k vocabulary cutoff for all agents; restricts sampling to the k
     /// highest-probability tokens (1–1000).
@@ -125,6 +125,49 @@ pub struct ForgeConfig {
     pub tool_supported: bool,
 }
 
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+    use crate::reader::ConfigReader;
+
+    #[test]
+    fn test_f32_temperature_round_trip() {
+        let fixture = ForgeConfig { temperature: Some(Decimal(0.1)), ..Default::default() };
+
+        let toml = toml_edit::ser::to_string_pretty(&fixture).unwrap();
+
+        assert!(
+            toml.contains("temperature = 0.1\n"),
+            "expected `temperature = 0.1` in TOML output, got:\n{toml}"
+        );
+    }
+
+    #[test]
+    fn test_f32_top_p_round_trip() {
+        let fixture = ForgeConfig { top_p: Some(Decimal(0.9)), ..Default::default() };
+
+        let toml = toml_edit::ser::to_string_pretty(&fixture).unwrap();
+
+        assert!(
+            toml.contains("top_p = 0.9\n"),
+            "expected `top_p = 0.9` in TOML output, got:\n{toml}"
+        );
+    }
+
+    #[test]
+    fn test_f32_temperature_deserialize_round_trip() {
+        let fixture = ForgeConfig { temperature: Some(Decimal(0.1)), ..Default::default() };
+
+        let toml = toml_edit::ser::to_string_pretty(&fixture).unwrap();
+
+        let actual = ConfigReader::default().read_toml(&toml).build().unwrap();
+
+        assert_eq!(actual.temperature, fixture.temperature);
+    }
+}
+
 impl ForgeConfig {
     /// Reads and merges configuration from all sources, returning the resolved
     /// [`ForgeConfig`].

crates/forge_config/src/decimal.rs

@@ -0,0 +1,94 @@
+/// A floating-point newtype that serializes to two decimal places, preventing
+/// `toml_edit` from emitting noisy bit-pattern approximations such as
+/// `0.10000000149011612` or `0.20000000000000001`.
+///
+/// The inner value is stored as `f64`. When used for fields that ultimately
+/// require `f32`, callers should cast via `value() as f32`.
+pub struct Decimal(pub f64);
+
+impl Decimal {
+    /// Returns the inner `f64` value.
+    pub fn value(&self) -> f64 {
+        self.0
+    }
+}
+
+impl std::fmt::Debug for Decimal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl Clone for Decimal {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl Copy for Decimal {}
+
+impl PartialEq for Decimal {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl PartialOrd for Decimal {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.0.partial_cmp(&other.0)
+    }
+}
+
+impl Default for Decimal {
+    fn default() -> Self {
+        Self(0.0)
+    }
+}
+
+impl From<f64> for Decimal {
+    fn from(v: f64) -> Self {
+        Self(v)
+    }
+}
+
+impl From<f32> for Decimal {
+    fn from(v: f32) -> Self {
+        Self(v as f64)
+    }
+}
+
+impl From<Decimal> for f64 {
+    fn from(d: Decimal) -> Self {
+        d.0
+    }
+}
+
+impl schemars::JsonSchema for Decimal {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        f64::schema_name()
+    }
+
+    fn json_schema(r#gen: &mut schemars::generate::SchemaGenerator) -> schemars::Schema {
+        f64::json_schema(r#gen)
+    }
+}
+
+impl fake::Dummy<fake::Faker> for Decimal {
+    fn dummy_with_rng<R: fake::RngExt + ?Sized>(_: &fake::Faker, rng: &mut R) -> Self {
+        use fake::Fake;
+        Self((0.0f64..2.0f64).fake_with_rng(rng))
+    }
+}
+
+impl serde::Serialize for Decimal {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let formatted: f64 = format!("{:.2}", self.0).parse().unwrap();
+        serializer.serialize_f64(formatted)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for Decimal {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        Ok(Self(f64::deserialize(deserializer)?))
+    }
+}

crates/forge_config/src/lib.rs

@@ -1,20 +1,24 @@
 mod auto_dump;
 mod compact;
 mod config;
+mod decimal;
 mod error;
 mod http;
 mod legacy;
 mod model;
+mod percentage;
 mod reader;
 mod retry;
 mod writer;
 
 pub use auto_dump::*;
 pub use compact::*;
 pub use config::*;
+pub use decimal::*;
 pub use error::Error;
 pub use http::*;
 pub use model::*;
+pub use percentage::*;
 pub use reader::*;
 pub use retry::*;
 pub use writer::*;