Add supported reasoning efforts to provider models

nodejs/src/types.ts

@@ -3766,6 +3766,11 @@ export interface ProviderModelConfig {
      */
     maxOutputTokens?: number;
 
+    /**
+     * Reasoning effort levels supported by the model.
+     */
+    supportedReasoningEfforts?: ReasoningEffort[];
+
     /**
      * Optional capability overrides (vision, tool_calls, reasoning, etc.) for
      * the synthesized model.

rust/src/types.rs

@@ -1879,6 +1879,9 @@ pub struct ProviderModelConfig {
     /// Overrides the resolved model's default max output tokens.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub max_output_tokens: Option<i64>,
+    /// Reasoning effort levels supported by the model.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub supported_reasoning_efforts: Option<Vec<String>>,
     /// Per-property overrides for model capabilities, deep-merged over
     /// runtime defaults.
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -1933,6 +1936,15 @@ impl ProviderModelConfig {
         self
     }
 
+    /// Set the reasoning effort levels supported by this model.
+    pub fn with_supported_reasoning_efforts(
+        mut self,
+        efforts: impl IntoIterator<Item = impl Into<String>>,
+    ) -> Self {
+        self.supported_reasoning_efforts = Some(efforts.into_iter().map(Into::into).collect());
+        self
+    }
+
     /// Set per-property model capability overrides.
     pub fn with_capabilities(
         mut self,

rust/src/types/tests.rs

@@ -907,7 +907,8 @@ fn session_config_into_wire_serializes_named_providers_and_models() {
         .with_models(vec![
             ProviderModelConfig::new("gpt-x", "my-openai")
                 .with_wire_model("gpt-x-2025")
-                .with_max_output_tokens(2048),
+                .with_max_output_tokens(2048)
+                .with_supported_reasoning_efforts(["low", "high"]),
         ]);
 
     let (wire, _) = cfg
@@ -927,6 +928,10 @@ fn session_config_into_wire_serializes_named_providers_and_models() {
     assert_eq!(wire_json["models"][0]["provider"], "my-openai");
     assert_eq!(wire_json["models"][0]["wireModel"], "gpt-x-2025");
     assert_eq!(wire_json["models"][0]["maxOutputTokens"], 2048);
+    assert_eq!(
+        wire_json["models"][0]["supportedReasoningEfforts"],
+        serde_json::json!(["low", "high"])
+    );
 
     let (empty_wire, _) = SessionConfig::default()
         .into_wire(Some(SessionId::from("empty")))
@@ -936,6 +941,41 @@ fn session_config_into_wire_serializes_named_providers_and_models() {
     assert!(empty_json.get("models").is_none());
 }
 
+#[test]
+fn provider_model_config_preserves_omission_compatibility() {
+    let model_json = serde_json::to_value(ProviderModelConfig::new("gpt-x", "my-openai")).unwrap();
+    assert!(model_json.get("supportedReasoningEfforts").is_none());
+
+    let legacy_model: ProviderModelConfig = serde_json::from_value(serde_json::json!({
+        "id": "gpt-x",
+        "provider": "my-openai"
+    }))
+    .unwrap();
+    assert!(legacy_model.supported_reasoning_efforts.is_none());
+}
+
+#[test]
+fn generated_provider_model_config_serializes_supported_reasoning_efforts() {
+    let model = crate::rpc::ProviderModelConfig {
+        id: "gpt-x".to_string(),
+        provider: "my-openai".to_string(),
+        supported_reasoning_efforts: Some(vec!["low".to_string(), "high".to_string()]),
+        ..Default::default()
+    };
+    let model_json = serde_json::to_value(model).unwrap();
+    assert_eq!(
+        model_json["supportedReasoningEfforts"],
+        serde_json::json!(["low", "high"])
+    );
+
+    let legacy_model: crate::rpc::ProviderModelConfig = serde_json::from_value(serde_json::json!({
+        "id": "gpt-x",
+        "provider": "my-openai"
+    }))
+    .unwrap();
+    assert!(legacy_model.supported_reasoning_efforts.is_none());
+}
+
 #[test]
 fn resume_config_into_wire_serializes_named_providers_and_models() {
     let cfg = ResumeSessionConfig::new(SessionId::from("sess-resume"))