feat: add Instant reasoning effort level

Add ReasoningEffort::Instant variant for near-realtime responses.
Map to None for OpenAI, "instant" for Chat Completions, and disabled
thinking for Anthropic. Fix Low reasoning effort to map to "low"
instead of "minimal" for OpenAI.

Author: razorback16

src/core/language_model/mod.rs

@@ -586,6 +586,8 @@ pub enum StopReason {
 /// Levels of reasoning effort for language models that support it.
 #[derive(Debug, Clone, Copy, Default)]
 pub enum ReasoningEffort {
+    /// Instant/no reasoning — near-realtime responses.
+    Instant,
     /// Low reasoning effort.
     #[default]
     Low,

src/providers/anthropic/conversions.rs

@@ -126,6 +126,8 @@ impl From<LanguageModelOptions> for AnthropicOptions {
 
         // convert reasoning to antropic thinking
         request.thinking(options.reasoning_effort.map(|effort| match effort {
+            // Instant disables thinking entirely
+            ReasoningEffort::Instant => AnthropicThinking::Disable,
             // Low is 25% of the max_tokens
             ReasoningEffort::Low => AnthropicThinking::Enable {
                 budget_tokens: (max_tokens / 4) as usize,

src/providers/openai/conversions.rs

@@ -171,7 +171,8 @@ impl From<types::ResponseUsage> for Usage {
 impl From<ReasoningEffort> for types::ReasoningEffort {
     fn from(value: ReasoningEffort) -> Self {
         match value {
-            ReasoningEffort::Low => client::ReasoningEffort::Minimal,
+            ReasoningEffort::Instant => client::ReasoningEffort::None,
+            ReasoningEffort::Low => client::ReasoningEffort::Low,
             ReasoningEffort::Medium => client::ReasoningEffort::Medium,
             ReasoningEffort::High => client::ReasoningEffort::High,
         }
@@ -214,11 +215,18 @@ mod tests {
         LanguageModelOptions, ReasoningEffort as LMReasoningEffort, Usage,
     };
 
+    #[test]
+    fn test_reasoning_effort_conversion_instant() {
+        let effort = LMReasoningEffort::Instant;
+        let openai_effort: ReasoningEffort = effort.into();
+        assert_eq!(openai_effort, ReasoningEffort::None);
+    }
+
     #[test]
     fn test_reasoning_effort_conversion_low() {
         let effort = LMReasoningEffort::Low;
         let openai_effort: ReasoningEffort = effort.into();
-        assert_eq!(openai_effort, ReasoningEffort::Minimal);
+        assert_eq!(openai_effort, ReasoningEffort::Low);
         let _ = openai_effort;
     }
 
@@ -236,6 +244,19 @@ mod tests {
         assert_eq!(openai_effort, ReasoningEffort::High);
     }
 
+    #[test]
+    fn test_language_model_options_to_create_response_with_reasoning_effort_instant() {
+        let options = LanguageModelOptions {
+            reasoning_effort: Some(LMReasoningEffort::Instant),
+            ..Default::default()
+        };
+        let lm_options: OpenAILanguageModelOptions = options.into();
+        assert!(lm_options.reasoning.is_some());
+        let reasoning = lm_options.reasoning.unwrap();
+        assert_eq!(reasoning.effort, Some(ReasoningEffort::None));
+        assert_eq!(reasoning.summary, Some(SummaryType::Auto));
+    }
+
     #[test]
     fn test_language_model_options_to_create_response_with_reasoning_effort_low() {
         let options = LanguageModelOptions {
@@ -245,7 +266,7 @@ mod tests {
         let lm_options: OpenAILanguageModelOptions = options.into();
         assert!(lm_options.reasoning.is_some());
         let reasoning = lm_options.reasoning.unwrap();
-        assert_eq!(reasoning.effort, Some(ReasoningEffort::Minimal));
+        assert_eq!(reasoning.effort, Some(ReasoningEffort::Low));
         assert_eq!(reasoning.summary, Some(SummaryType::Auto));
     }
 

src/providers/openai_chat_completions/conversions.rs

@@ -72,6 +72,7 @@ impl From<LanguageModelOptions> for client::ChatCompletionsOptions {
 
         let reasoning_effort = options.reasoning_effort.map(|effort| {
             match effort {
+                ReasoningEffort::Instant => "instant",
                 ReasoningEffort::Low => "low",
                 ReasoningEffort::Medium => "medium",
                 ReasoningEffort::High => "high",