feat: enforce full format field coverage audit

crates/aether-ai-formats/src/formats/gemini/generate_content/request.rs

@@ -15,7 +15,7 @@ use crate::{
         apply_gemini_request_extensions, canonical_extension_object_mut,
         canonical_openai_reasoning_effort, extract_gemini_model_from_path,
         gemini_contents_to_canonical_messages, gemini_extensions, gemini_generation_config,
-        gemini_generation_config_extra, gemini_google_search_grounding, gemini_openai_extra_body,
+        gemini_generation_config_extra, gemini_google_search_grounding,
         gemini_response_format_to_canonical, gemini_system_to_canonical_instructions,
         gemini_thinking_to_canonical, gemini_tool_choice_to_canonical, gemini_tools_to_canonical,
         gemini_value_by_case, CanonicalContentBlock, CanonicalMessage, CanonicalRequest,
@@ -173,10 +173,6 @@ pub fn from_raw(body_json: &Value, request_path: &str) -> Option<CanonicalReques
         canonical_extension_object_mut(&mut canonical.extensions, "gemini")
             .insert("raw_tool_config".to_string(), tool_config);
     }
-    if let Some(extra_body) = gemini_openai_extra_body(request) {
-        canonical_extension_object_mut(&mut canonical.extensions, "openai")
-            .insert("extra_body".to_string(), extra_body);
-    }
     if let Some(web_search_options) = web_search_options {
         canonical_extension_object_mut(&mut canonical.extensions, "openai")
             .insert("web_search_options".to_string(), web_search_options);

crates/aether-ai-formats/src/formats/openai/responses/request.rs

@@ -5,7 +5,7 @@ use serde_json::{json, Map, Value};
 use crate::{
     formats::context::FormatContext,
     formats::openai::shared::{
-        map_thinking_budget_to_openai_reasoning_effort, OpenAiReasoningEffort,
+        map_thinking_budget_to_openai_reasoning_effort, OpenAiResponsesReasoningEffort,
     },
     protocol::canonical::{
         canonical_response_format_to_openai, canonicalize_tool_arguments,
@@ -660,7 +660,9 @@ fn reasoning_config_to_responses(thinking: &CanonicalThinkingConfig) -> Option<V
 fn openai_responses_reasoning_effort(effort: &str) -> Option<&'static str> {
     match effort.trim().to_ascii_lowercase().as_str() {
         "max" => Some("xhigh"),
-        value => OpenAiReasoningEffort::parse(value).map(OpenAiReasoningEffort::as_str),
+        value => {
+            OpenAiResponsesReasoningEffort::parse(value).map(OpenAiResponsesReasoningEffort::as_str)
+        }
     }
 }
 

crates/aether-ai-formats/src/formats/openai/shared.rs

@@ -2,40 +2,50 @@ use serde_json::{Map, Value};
 
 use crate::formats::shared::model_directives::ReasoningEffort;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum OpenAiReasoningEffort {
-    None,
-    Minimal,
-    Low,
-    Medium,
-    High,
-    XHigh,
+macro_rules! define_openai_reasoning_effort {
+    ($name:ident) => {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub enum $name {
+            None,
+            Minimal,
+            Low,
+            Medium,
+            High,
+            XHigh,
+        }
+
+        impl $name {
+            pub fn parse(value: &str) -> Option<Self> {
+                match value.trim().to_ascii_lowercase().as_str() {
+                    "none" => Some(Self::None),
+                    "minimal" => Some(Self::Minimal),
+                    "low" => Some(Self::Low),
+                    "medium" => Some(Self::Medium),
+                    "high" => Some(Self::High),
+                    "xhigh" => Some(Self::XHigh),
+                    _ => None,
+                }
+            }
+
+            pub fn as_str(self) -> &'static str {
+                match self {
+                    Self::None => "none",
+                    Self::Minimal => "minimal",
+                    Self::Low => "low",
+                    Self::Medium => "medium",
+                    Self::High => "high",
+                    Self::XHigh => "xhigh",
+                }
+            }
+        }
+    };
 }
 
-impl OpenAiReasoningEffort {
-    pub fn parse(value: &str) -> Option<Self> {
-        match value.trim().to_ascii_lowercase().as_str() {
-            "none" => Some(Self::None),
-            "minimal" => Some(Self::Minimal),
-            "low" => Some(Self::Low),
-            "medium" => Some(Self::Medium),
-            "high" => Some(Self::High),
-            "xhigh" => Some(Self::XHigh),
-            _ => None,
-        }
-    }
+define_openai_reasoning_effort!(OpenAiChatReasoningEffort);
+define_openai_reasoning_effort!(OpenAiResponsesReasoningEffort);
 
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::None => "none",
-            Self::Minimal => "minimal",
-            Self::Low => "low",
-            Self::Medium => "medium",
-            Self::High => "high",
-            Self::XHigh => "xhigh",
-        }
-    }
-}
+#[deprecated(note = "use OpenAiChatReasoningEffort or OpenAiResponsesReasoningEffort")]
+pub type OpenAiReasoningEffort = OpenAiChatReasoningEffort;
 
 pub fn parse_openai_stop_sequences(stop: Option<&Value>) -> Option<Vec<Value>> {
     match stop {