diff --git a/Cargo.lock b/Cargo.lock
index c0711dee737..46c2fc46e2f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9811,6 +9811,7 @@ dependencies = [
  "async-lock",
  "aws-config",
  "aws-credential-types",
+ "aws-sigv4",
  "aws_http_client",
  "base64 0.22.1",
  "bedrock",
diff --git a/Cargo.toml b/Cargo.toml
index 3611fce865b..7a7003ec5eb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -543,6 +543,7 @@ aws-credential-types = { version = "1.2.8", features = [
 aws-sdk-bedrockruntime = { version = "1.112.0", features = [
     "behavior-version-latest",
 ] }
+aws-sigv4 = { version = "1.4.0", features = ["http1"] }
 aws-smithy-runtime-api = { version = "1.9.2", features = ["http-1x", "client"] }
 aws-smithy-types = { version = "1.3.4", features = ["http-body-1-x"] }
 backtrace = "0.3"
diff --git a/crates/bedrock/src/models.rs b/crates/bedrock/src/models.rs
index ce5241a2dbb..cd035be8198 100644
--- a/crates/bedrock/src/models.rs
+++ b/crates/bedrock/src/models.rs
@@ -46,7 +46,7 @@ pub struct BedrockModelCacheConfiguration {
 
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
-pub enum Model {
+pub enum ConverseModel {
     // Anthropic Claude 4+ models
     #[serde(
         rename = "claude-fable-5",
@@ -227,7 +227,7 @@ pub enum Model {
     },
 }
 
-impl Model {
+impl ConverseModel {
     pub fn default_fast(_region: &str) -> Self {
         Self::ClaudeHaiku4_5
     }
@@ -817,34 +817,162 @@ impl Model {
     }
 }
 
+/// The wire protocol used to talk to a [`MantleModel`] on the `bedrock-mantle` endpoint.
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq, EnumIter)]
+pub enum MantleProtocol {
+    /// The OpenAI Chat Completions API (`/chat/completions`).
+    #[default]
+    ChatCompletions,
+    /// The OpenAI Responses API (`/responses`).
+    Responses,
+}
+
+/// Models only reachable through the `bedrock-mantle` endpoint's
+/// OpenAI-compatible APIs, i.e. with no `Converse`/`Invoke` support on
+/// `bedrock-runtime`.
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, EnumIter)]
+pub enum MantleModel {
+    #[serde(rename = "gpt-5.5")]
+    Gpt5_5,
+    #[serde(rename = "gpt-5.4")]
+    Gpt5_4,
+    #[serde(rename = "grok-4.3")]
+    Grok4_3,
+    #[serde(rename = "custom")]
+    Custom {
+        name: String,
+        display_name: Option<String>,
+        max_tokens: u64,
+        max_output_tokens: Option<u64>,
+        protocol: MantleProtocol,
+        supports_tools: bool,
+        supports_images: bool,
+        supports_thinking: bool,
+    },
+}
+
+impl MantleModel {
+    /// The model id Zed uses internally (also used as the `name` in settings).
+    pub fn id(&self) -> &str {
+        match self {
+            Self::Gpt5_5 => "gpt-5.5",
+            Self::Gpt5_4 => "gpt-5.4",
+            Self::Grok4_3 => "grok-4.3",
+            Self::Custom { name, .. } => name,
+        }
+    }
+
+    /// The model id as expected in Bedrock Mantle request bodies, e.g. `openai.gpt-5.5`.
+    pub fn request_id(&self) -> &str {
+        match self {
+            Self::Gpt5_5 => "openai.gpt-5.5",
+            Self::Gpt5_4 => "openai.gpt-5.4",
+            Self::Grok4_3 => "xai.grok-4.3",
+            Self::Custom { name, .. } => name,
+        }
+    }
+
+    pub fn display_name(&self) -> &str {
+        match self {
+            Self::Gpt5_5 => "GPT-5.5",
+            Self::Gpt5_4 => "GPT-5.4",
+            Self::Grok4_3 => "Grok 4.3",
+            Self::Custom {
+                display_name, name, ..
+            } => display_name.as_deref().unwrap_or(name.as_str()),
+        }
+    }
+
+    /// Which OpenAI-compatible API this model must be called through.
+    pub fn protocol(&self) -> MantleProtocol {
+        match self {
+            Self::Gpt5_5 | Self::Gpt5_4 | Self::Grok4_3 => MantleProtocol::Responses,
+            Self::Custom { protocol, .. } => *protocol,
+        }
+    }
+
+    pub fn max_token_count(&self) -> u64 {
+        match self {
+            Self::Gpt5_5 | Self::Gpt5_4 => 272_000,
+            Self::Grok4_3 => 1_000_000,
+            Self::Custom { max_tokens, .. } => *max_tokens,
+        }
+    }
+
+    pub fn max_output_tokens(&self) -> u64 {
+        match self {
+            // AWS doesn't document a hard cap for GPT-5.5/5.4 on Mantle.
+            Self::Gpt5_5 | Self::Gpt5_4 => 128_000,
+            Self::Grok4_3 => 131_072,
+            Self::Custom {
+                max_output_tokens, ..
+            } => max_output_tokens.unwrap_or(4_096),
+        }
+    }
+
+    pub fn supports_tools(&self) -> bool {
+        match self {
+            Self::Gpt5_5 | Self::Gpt5_4 | Self::Grok4_3 => true,
+            Self::Custom { supports_tools, .. } => *supports_tools,
+        }
+    }
+
+    pub fn supports_images(&self) -> bool {
+        match self {
+            Self::Gpt5_5 | Self::Gpt5_4 | Self::Grok4_3 => true,
+            Self::Custom {
+                supports_images, ..
+            } => *supports_images,
+        }
+    }
+
+    pub fn supports_thinking(&self) -> bool {
+        match self {
+            Self::Gpt5_5 | Self::Gpt5_4 | Self::Grok4_3 => true,
+            Self::Custom {
+                supports_thinking, ..
+            } => *supports_thinking,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_builtin_mantle_models_use_responses_protocol() {
+        assert_eq!(MantleModel::Gpt5_5.protocol(), MantleProtocol::Responses);
+        assert_eq!(MantleModel::Gpt5_4.protocol(), MantleProtocol::Responses);
+        assert_eq!(MantleModel::Grok4_3.protocol(), MantleProtocol::Responses);
+    }
+
     #[test]
     fn test_us_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("us-east-1", false)?,
             "us.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::ClaudeSonnet4.cross_region_inference_id("us-west-2", false)?,
+            ConverseModel::ClaudeSonnet4.cross_region_inference_id("us-west-2", false)?,
             "us.anthropic.claude-sonnet-4-20250514-v1:0"
         );
         assert_eq!(
-            Model::ClaudeFable5.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::ClaudeFable5.cross_region_inference_id("us-east-1", false)?,
             "us.anthropic.claude-fable-5"
         );
         assert_eq!(
-            Model::ClaudeSonnet5.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::ClaudeSonnet5.cross_region_inference_id("us-east-1", false)?,
             "us.anthropic.claude-sonnet-5"
         );
         assert_eq!(
-            Model::NovaPro.cross_region_inference_id("us-east-2", false)?,
+            ConverseModel::NovaPro.cross_region_inference_id("us-east-2", false)?,
             "us.amazon.nova-pro-v1:0"
         );
         assert_eq!(
-            Model::DeepSeekR1.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::DeepSeekR1.cross_region_inference_id("us-east-1", false)?,
             "us.deepseek.r1-v1:0"
         );
         Ok(())
@@ -853,27 +981,27 @@ mod tests {
     #[test]
     fn test_eu_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeSonnet4.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeSonnet4.cross_region_inference_id("eu-west-1", false)?,
             "eu.anthropic.claude-sonnet-4-20250514-v1:0"
         );
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("eu-west-1", false)?,
             "eu.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::NovaLite.cross_region_inference_id("eu-north-1", false)?,
+            ConverseModel::NovaLite.cross_region_inference_id("eu-north-1", false)?,
             "eu.amazon.nova-lite-v1:0"
         );
         assert_eq!(
-            Model::ClaudeOpus4_6.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeOpus4_6.cross_region_inference_id("eu-west-1", false)?,
             "eu.anthropic.claude-opus-4-6-v1"
         );
         assert_eq!(
-            Model::ClaudeOpus4_7.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeOpus4_7.cross_region_inference_id("eu-west-1", false)?,
             "eu.anthropic.claude-opus-4-7"
         );
         assert_eq!(
-            Model::ClaudeOpus4_8.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeOpus4_8.cross_region_inference_id("eu-west-1", false)?,
             "eu.anthropic.claude-opus-4-8"
         );
         Ok(())
@@ -882,19 +1010,19 @@ mod tests {
     #[test]
     fn test_inference_profile_only_models_fall_back_to_global() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeFable5.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeFable5.cross_region_inference_id("eu-west-1", false)?,
             "global.anthropic.claude-fable-5"
         );
         assert_eq!(
-            Model::ClaudeSonnet5.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::ClaudeSonnet5.cross_region_inference_id("eu-west-1", false)?,
             "global.anthropic.claude-sonnet-5"
         );
         assert_eq!(
-            Model::ClaudeFable5.cross_region_inference_id("ap-southeast-2", false)?,
+            ConverseModel::ClaudeFable5.cross_region_inference_id("ap-southeast-2", false)?,
             "global.anthropic.claude-fable-5"
         );
         assert_eq!(
-            Model::ClaudeSonnet5.cross_region_inference_id("ap-northeast-1", false)?,
+            ConverseModel::ClaudeSonnet5.cross_region_inference_id("ap-northeast-1", false)?,
             "global.anthropic.claude-sonnet-5"
         );
         Ok(())
@@ -903,11 +1031,11 @@ mod tests {
     #[test]
     fn test_apac_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("ap-south-1", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("ap-south-1", false)?,
             "apac.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::NovaLite.cross_region_inference_id("ap-south-1", false)?,
+            ConverseModel::NovaLite.cross_region_inference_id("ap-south-1", false)?,
             "apac.amazon.nova-lite-v1:0"
         );
         Ok(())
@@ -916,23 +1044,23 @@ mod tests {
     #[test]
     fn test_au_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeHaiku4_5.cross_region_inference_id("ap-southeast-2", false)?,
+            ConverseModel::ClaudeHaiku4_5.cross_region_inference_id("ap-southeast-2", false)?,
             "au.anthropic.claude-haiku-4-5-20251001-v1:0"
         );
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("ap-southeast-4", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("ap-southeast-4", false)?,
             "au.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::ClaudeOpus4_6.cross_region_inference_id("ap-southeast-2", false)?,
+            ConverseModel::ClaudeOpus4_6.cross_region_inference_id("ap-southeast-2", false)?,
             "au.anthropic.claude-opus-4-6-v1"
         );
         assert_eq!(
-            Model::ClaudeOpus4_7.cross_region_inference_id("ap-southeast-2", false)?,
+            ConverseModel::ClaudeOpus4_7.cross_region_inference_id("ap-southeast-2", false)?,
             "au.anthropic.claude-opus-4-7"
         );
         assert_eq!(
-            Model::ClaudeOpus4_8.cross_region_inference_id("ap-southeast-2", false)?,
+            ConverseModel::ClaudeOpus4_8.cross_region_inference_id("ap-southeast-2", false)?,
             "au.anthropic.claude-opus-4-8"
         );
         Ok(())
@@ -941,15 +1069,15 @@ mod tests {
     #[test]
     fn test_jp_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeHaiku4_5.cross_region_inference_id("ap-northeast-1", false)?,
+            ConverseModel::ClaudeHaiku4_5.cross_region_inference_id("ap-northeast-1", false)?,
             "jp.anthropic.claude-haiku-4-5-20251001-v1:0"
         );
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("ap-northeast-3", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("ap-northeast-3", false)?,
             "jp.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::Nova2Lite.cross_region_inference_id("ap-northeast-1", false)?,
+            ConverseModel::Nova2Lite.cross_region_inference_id("ap-northeast-1", false)?,
             "jp.amazon.nova-2-lite-v1:0"
         );
         Ok(())
@@ -958,7 +1086,7 @@ mod tests {
     #[test]
     fn test_ca_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::NovaLite.cross_region_inference_id("ca-central-1", false)?,
+            ConverseModel::NovaLite.cross_region_inference_id("ca-central-1", false)?,
             "ca.amazon.nova-lite-v1:0"
         );
         Ok(())
@@ -967,11 +1095,11 @@ mod tests {
     #[test]
     fn test_gov_region_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("us-gov-east-1", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("us-gov-east-1", false)?,
             "us-gov.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("us-gov-west-1", false)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("us-gov-west-1", false)?,
             "us-gov.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         Ok(())
@@ -980,45 +1108,45 @@ mod tests {
     #[test]
     fn test_global_inference_ids() -> anyhow::Result<()> {
         assert_eq!(
-            Model::ClaudeSonnet4.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::ClaudeSonnet4.cross_region_inference_id("us-east-1", true)?,
             "global.anthropic.claude-sonnet-4-20250514-v1:0"
         );
         assert_eq!(
-            Model::ClaudeSonnet4_5.cross_region_inference_id("eu-west-1", true)?,
+            ConverseModel::ClaudeSonnet4_5.cross_region_inference_id("eu-west-1", true)?,
             "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
         assert_eq!(
-            Model::ClaudeHaiku4_5.cross_region_inference_id("ap-south-1", true)?,
+            ConverseModel::ClaudeHaiku4_5.cross_region_inference_id("ap-south-1", true)?,
             "global.anthropic.claude-haiku-4-5-20251001-v1:0"
         );
         assert_eq!(
-            Model::ClaudeOpus4_6.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::ClaudeOpus4_6.cross_region_inference_id("us-east-1", true)?,
             "global.anthropic.claude-opus-4-6-v1"
         );
         assert_eq!(
-            Model::ClaudeOpus4_7.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::ClaudeOpus4_7.cross_region_inference_id("us-east-1", true)?,
             "global.anthropic.claude-opus-4-7"
         );
         assert_eq!(
-            Model::ClaudeOpus4_8.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::ClaudeOpus4_8.cross_region_inference_id("us-east-1", true)?,
             "global.anthropic.claude-opus-4-8"
         );
         assert_eq!(
-            Model::ClaudeFable5.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::ClaudeFable5.cross_region_inference_id("us-east-1", true)?,
             "global.anthropic.claude-fable-5"
         );
         assert_eq!(
-            Model::ClaudeSonnet5.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::ClaudeSonnet5.cross_region_inference_id("us-east-1", true)?,
             "global.anthropic.claude-sonnet-5"
         );
         assert_eq!(
-            Model::Nova2Lite.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::Nova2Lite.cross_region_inference_id("us-east-1", true)?,
             "global.amazon.nova-2-lite-v1:0"
         );
 
         // Models without global support fall back to regional
         assert_eq!(
-            Model::NovaPro.cross_region_inference_id("us-east-1", true)?,
+            ConverseModel::NovaPro.cross_region_inference_id("us-east-1", true)?,
             "us.amazon.nova-pro-v1:0"
         );
         Ok(())
@@ -1028,27 +1156,27 @@ mod tests {
     fn test_models_without_cross_region() -> anyhow::Result<()> {
         // Models without cross-region support return their request_id directly
         assert_eq!(
-            Model::Gemma3_4B.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::Gemma3_4B.cross_region_inference_id("us-east-1", false)?,
             "google.gemma-3-4b-it"
         );
         assert_eq!(
-            Model::MistralLarge3.cross_region_inference_id("eu-west-1", false)?,
+            ConverseModel::MistralLarge3.cross_region_inference_id("eu-west-1", false)?,
             "mistral.mistral-large-3-675b-instruct"
         );
         assert_eq!(
-            Model::Qwen3VL235B.cross_region_inference_id("ap-south-1", false)?,
+            ConverseModel::Qwen3VL235B.cross_region_inference_id("ap-south-1", false)?,
             "qwen.qwen3-vl-235b-a22b"
         );
         assert_eq!(
-            Model::GptOss120B.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::GptOss120B.cross_region_inference_id("us-east-1", false)?,
             "openai.gpt-oss-120b-1:0"
         );
         assert_eq!(
-            Model::MiniMaxM2.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::MiniMaxM2.cross_region_inference_id("us-east-1", false)?,
             "minimax.minimax-m2"
         );
         assert_eq!(
-            Model::KimiK2Thinking.cross_region_inference_id("us-east-1", false)?,
+            ConverseModel::KimiK2Thinking.cross_region_inference_id("us-east-1", false)?,
             "moonshot.kimi-k2-thinking"
         );
         Ok(())
@@ -1056,7 +1184,7 @@ mod tests {
 
     #[test]
     fn test_custom_model_inference_ids() -> anyhow::Result<()> {
-        let custom_model = Model::Custom {
+        let custom_model = ConverseModel::Custom {
             name: "custom.my-model-v1:0".to_string(),
             max_tokens: 100000,
             display_name: Some("My Custom Model".to_string()),
@@ -1078,78 +1206,90 @@ mod tests {
 
     #[test]
     fn test_friendly_id_vs_request_id() {
-        assert_eq!(Model::ClaudeSonnet4_5.id(), "claude-sonnet-4-5");
-        assert_eq!(Model::NovaLite.id(), "nova-lite");
-        assert_eq!(Model::DeepSeekR1.id(), "deepseek-r1");
-        assert_eq!(Model::Llama4Scout17B.id(), "llama-4-scout-17b");
-        assert_eq!(Model::ClaudeFable5.id(), "claude-fable-5");
-        assert_eq!(Model::ClaudeSonnet5.id(), "claude-sonnet-5");
+        assert_eq!(ConverseModel::ClaudeSonnet4_5.id(), "claude-sonnet-4-5");
+        assert_eq!(ConverseModel::NovaLite.id(), "nova-lite");
+        assert_eq!(ConverseModel::DeepSeekR1.id(), "deepseek-r1");
+        assert_eq!(ConverseModel::Llama4Scout17B.id(), "llama-4-scout-17b");
+        assert_eq!(ConverseModel::ClaudeFable5.id(), "claude-fable-5");
+        assert_eq!(ConverseModel::ClaudeSonnet5.id(), "claude-sonnet-5");
 
         assert_eq!(
-            Model::ClaudeSonnet4_5.request_id(),
+            ConverseModel::ClaudeSonnet4_5.request_id(),
             "anthropic.claude-sonnet-4-5-20250929-v1:0"
         );
-        assert_eq!(Model::NovaLite.request_id(), "amazon.nova-lite-v1:0");
-        assert_eq!(Model::DeepSeekR1.request_id(), "deepseek.r1-v1:0");
         assert_eq!(
-            Model::Llama4Scout17B.request_id(),
+            ConverseModel::NovaLite.request_id(),
+            "amazon.nova-lite-v1:0"
+        );
+        assert_eq!(ConverseModel::DeepSeekR1.request_id(), "deepseek.r1-v1:0");
+        assert_eq!(
+            ConverseModel::Llama4Scout17B.request_id(),
             "meta.llama4-scout-17b-instruct-v1:0"
         );
-        assert_eq!(Model::ClaudeFable5.request_id(), "anthropic.claude-fable-5");
         assert_eq!(
-            Model::ClaudeSonnet5.request_id(),
+            ConverseModel::ClaudeFable5.request_id(),
+            "anthropic.claude-fable-5"
+        );
+        assert_eq!(
+            ConverseModel::ClaudeSonnet5.request_id(),
             "anthropic.claude-sonnet-5"
         );
 
         // Thinking aliases deserialize to the same model
-        assert_eq!(Model::ClaudeSonnet4.id(), "claude-sonnet-4");
+        assert_eq!(ConverseModel::ClaudeSonnet4.id(), "claude-sonnet-4");
         assert_eq!(
-            Model::from_id("claude-sonnet-4-thinking").unwrap().id(),
+            ConverseModel::from_id("claude-sonnet-4-thinking")
+                .unwrap()
+                .id(),
             "claude-sonnet-4"
         );
         assert_eq!(
-            Model::from_id("claude-fable-5-thinking").unwrap().id(),
+            ConverseModel::from_id("claude-fable-5-thinking")
+                .unwrap()
+                .id(),
             "claude-fable-5"
         );
         assert_eq!(
-            Model::from_id("claude-sonnet-5-thinking").unwrap().id(),
+            ConverseModel::from_id("claude-sonnet-5-thinking")
+                .unwrap()
+                .id(),
             "claude-sonnet-5"
         );
     }
 
     #[test]
     fn test_thinking_modes() {
-        assert!(Model::ClaudeHaiku4_5.supports_thinking());
-        assert!(Model::ClaudeSonnet4.supports_thinking());
-        assert!(Model::ClaudeSonnet4_5.supports_thinking());
-        assert!(Model::ClaudeOpus4_6.supports_thinking());
-        assert!(Model::ClaudeFable5.supports_thinking());
+        assert!(ConverseModel::ClaudeHaiku4_5.supports_thinking());
+        assert!(ConverseModel::ClaudeSonnet4.supports_thinking());
+        assert!(ConverseModel::ClaudeSonnet4_5.supports_thinking());
+        assert!(ConverseModel::ClaudeOpus4_6.supports_thinking());
+        assert!(ConverseModel::ClaudeFable5.supports_thinking());
 
-        assert!(!Model::ClaudeSonnet4.supports_adaptive_thinking());
-        assert!(Model::ClaudeOpus4_6.supports_adaptive_thinking());
-        assert!(Model::ClaudeSonnet4_6.supports_adaptive_thinking());
-        assert!(Model::ClaudeFable5.supports_adaptive_thinking());
-        assert!(Model::ClaudeSonnet5.supports_adaptive_thinking());
-        assert!(!Model::ClaudeOpus4_7.supports_xhigh_adaptive_thinking());
-        assert!(Model::ClaudeFable5.supports_xhigh_adaptive_thinking());
-        assert!(Model::ClaudeSonnet5.supports_xhigh_adaptive_thinking());
-        assert!(Model::ClaudeOpus4_8.supports_xhigh_adaptive_thinking());
+        assert!(!ConverseModel::ClaudeSonnet4.supports_adaptive_thinking());
+        assert!(ConverseModel::ClaudeOpus4_6.supports_adaptive_thinking());
+        assert!(ConverseModel::ClaudeSonnet4_6.supports_adaptive_thinking());
+        assert!(ConverseModel::ClaudeFable5.supports_adaptive_thinking());
+        assert!(ConverseModel::ClaudeSonnet5.supports_adaptive_thinking());
+        assert!(!ConverseModel::ClaudeOpus4_7.supports_xhigh_adaptive_thinking());
+        assert!(ConverseModel::ClaudeFable5.supports_xhigh_adaptive_thinking());
+        assert!(ConverseModel::ClaudeSonnet5.supports_xhigh_adaptive_thinking());
+        assert!(ConverseModel::ClaudeOpus4_8.supports_xhigh_adaptive_thinking());
         assert_eq!(BedrockAdaptiveThinkingEffort::XHigh.as_str(), "xhigh");
 
         assert_eq!(
-            Model::ClaudeSonnet4.thinking_mode(),
+            ConverseModel::ClaudeSonnet4.thinking_mode(),
             BedrockModelMode::Thinking {
                 budget_tokens: Some(4096)
             }
         );
         assert_eq!(
-            Model::ClaudeOpus4_6.thinking_mode(),
+            ConverseModel::ClaudeOpus4_6.thinking_mode(),
             BedrockModelMode::AdaptiveThinking {
                 effort: BedrockAdaptiveThinkingEffort::High
             }
         );
         assert_eq!(
-            Model::ClaudeHaiku4_5.thinking_mode(),
+            ConverseModel::ClaudeHaiku4_5.thinking_mode(),
             BedrockModelMode::Thinking {
                 budget_tokens: Some(4096)
             }
@@ -1158,44 +1298,44 @@ mod tests {
 
     #[test]
     fn test_max_token_count() {
-        assert_eq!(Model::ClaudeSonnet4_5.max_token_count(), 1_000_000);
-        assert_eq!(Model::ClaudeOpus4_6.max_token_count(), 1_000_000);
-        assert_eq!(Model::ClaudeFable5.max_token_count(), 1_000_000);
-        assert_eq!(Model::ClaudeSonnet5.max_token_count(), 1_000_000);
-        assert_eq!(Model::Llama4Scout17B.max_token_count(), 128_000);
-        assert_eq!(Model::NovaPremier.max_token_count(), 1_000_000);
+        assert_eq!(ConverseModel::ClaudeSonnet4_5.max_token_count(), 1_000_000);
+        assert_eq!(ConverseModel::ClaudeOpus4_6.max_token_count(), 1_000_000);
+        assert_eq!(ConverseModel::ClaudeFable5.max_token_count(), 1_000_000);
+        assert_eq!(ConverseModel::ClaudeSonnet5.max_token_count(), 1_000_000);
+        assert_eq!(ConverseModel::Llama4Scout17B.max_token_count(), 128_000);
+        assert_eq!(ConverseModel::NovaPremier.max_token_count(), 1_000_000);
     }
 
     #[test]
     fn test_max_output_tokens() {
-        assert_eq!(Model::ClaudeSonnet4_5.max_output_tokens(), 64_000);
-        assert_eq!(Model::ClaudeOpus4_6.max_output_tokens(), 128_000);
-        assert_eq!(Model::ClaudeFable5.max_output_tokens(), 128_000);
-        assert_eq!(Model::ClaudeSonnet5.max_output_tokens(), 128_000);
-        assert_eq!(Model::ClaudeOpus4_1.max_output_tokens(), 32_000);
-        assert_eq!(Model::Gemma3_4B.max_output_tokens(), 8_192);
+        assert_eq!(ConverseModel::ClaudeSonnet4_5.max_output_tokens(), 64_000);
+        assert_eq!(ConverseModel::ClaudeOpus4_6.max_output_tokens(), 128_000);
+        assert_eq!(ConverseModel::ClaudeFable5.max_output_tokens(), 128_000);
+        assert_eq!(ConverseModel::ClaudeSonnet5.max_output_tokens(), 128_000);
+        assert_eq!(ConverseModel::ClaudeOpus4_1.max_output_tokens(), 32_000);
+        assert_eq!(ConverseModel::Gemma3_4B.max_output_tokens(), 8_192);
     }
 
     #[test]
     fn test_supports_tool_use() {
-        assert!(Model::ClaudeSonnet4_5.supports_tool_use());
-        assert!(Model::ClaudeFable5.supports_tool_use());
-        assert!(Model::NovaPro.supports_tool_use());
-        assert!(Model::MistralLarge3.supports_tool_use());
-        assert!(!Model::Gemma3_4B.supports_tool_use());
-        assert!(Model::Qwen3_32B.supports_tool_use());
-        assert!(Model::MiniMaxM2.supports_tool_use());
-        assert!(Model::KimiK2_5.supports_tool_use());
-        assert!(Model::DeepSeekR1.supports_tool_use());
-        assert!(!Model::Llama4Scout17B.supports_tool_use());
+        assert!(ConverseModel::ClaudeSonnet4_5.supports_tool_use());
+        assert!(ConverseModel::ClaudeFable5.supports_tool_use());
+        assert!(ConverseModel::NovaPro.supports_tool_use());
+        assert!(ConverseModel::MistralLarge3.supports_tool_use());
+        assert!(!ConverseModel::Gemma3_4B.supports_tool_use());
+        assert!(ConverseModel::Qwen3_32B.supports_tool_use());
+        assert!(ConverseModel::MiniMaxM2.supports_tool_use());
+        assert!(ConverseModel::KimiK2_5.supports_tool_use());
+        assert!(ConverseModel::DeepSeekR1.supports_tool_use());
+        assert!(!ConverseModel::Llama4Scout17B.supports_tool_use());
     }
 
     #[test]
     fn test_supports_caching() {
-        assert!(Model::ClaudeSonnet4_5.supports_caching());
-        assert!(Model::ClaudeOpus4_6.supports_caching());
-        assert!(Model::ClaudeFable5.supports_caching());
-        assert!(!Model::Llama4Scout17B.supports_caching());
-        assert!(!Model::NovaPro.supports_caching());
+        assert!(ConverseModel::ClaudeSonnet4_5.supports_caching());
+        assert!(ConverseModel::ClaudeOpus4_6.supports_caching());
+        assert!(ConverseModel::ClaudeFable5.supports_caching());
+        assert!(!ConverseModel::Llama4Scout17B.supports_caching());
+        assert!(!ConverseModel::NovaPro.supports_caching());
     }
 }
diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml
index 57a0d530e45..8da9eb332ed 100644
--- a/crates/language_models/Cargo.toml
+++ b/crates/language_models/Cargo.toml
@@ -18,6 +18,7 @@ anthropic = { workspace = true, features = ["schemars"] }
 anyhow.workspace = true
 aws-config = { workspace = true, features = ["behavior-version-latest"] }
 aws-credential-types = { workspace = true, features = ["hardcoded-credentials"] }
+aws-sigv4.workspace = true
 aws_http_client.workspace = true
 base64.workspace = true
 bedrock = { workspace = true, features = ["schemars"] }
diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs
index ba3b587151a..fe12a5eb3a1 100644
--- a/crates/language_models/src/provider/bedrock.rs
+++ b/crates/language_models/src/provider/bedrock.rs
@@ -5,8 +5,11 @@ use anyhow::{Context as _, Result, anyhow};
 use async_lock::OnceCell;
 use aws_config::stalled_stream_protection::StalledStreamProtectionConfig;
 use aws_config::{BehaviorVersion, Region};
+use aws_credential_types::provider::{ProvideCredentials, SharedCredentialsProvider};
 use aws_credential_types::{Credentials, Token};
 use aws_http_client::AwsHttpClient;
+use aws_sigv4::http_request::{SignableBody, SignableRequest, SigningSettings, sign};
+use aws_sigv4::sign::v4;
 use bedrock::BedrockSystemContentBlock;
 use bedrock::bedrock_client::Client as BedrockClient;
 use bedrock::bedrock_client::config::timeout::TimeoutConfig;
@@ -20,37 +23,53 @@ use bedrock::{
     BedrockStreamingResponse, BedrockThinkingBlock, BedrockThinkingTextBlock, BedrockTool,
     BedrockToolChoice, BedrockToolConfig, BedrockToolInputSchema, BedrockToolResultBlock,
     BedrockToolResultContentBlock, BedrockToolResultStatus, BedrockToolSpec, BedrockToolUseBlock,
-    Model, value_to_aws_document,
+    ConverseModel, MantleModel, MantleProtocol, value_to_aws_document,
 };
 use collections::{BTreeMap, HashMap};
 use credentials_provider::CredentialsProvider;
-use futures::{FutureExt, Stream, StreamExt, future::BoxFuture, stream::BoxStream};
+use futures::{
+    AsyncBufReadExt, AsyncReadExt, FutureExt, Stream, StreamExt, future::BoxFuture, io::BufReader,
+    stream::BoxStream,
+};
 use gpui::{
     App, AsyncApp, Context, Entity, FocusHandle, Subscription, Task, TaskExt, Window, actions,
 };
 use gpui_tokio::Tokio;
-use http_client::HttpClient;
+use http_client::{
+    AsyncBody, CustomHeaders, HttpClient, Method, Request as HttpRequest, RequestBuilderExt,
+    http::{HeaderValue, header::AUTHORIZATION},
+};
 use language_model::{
     AuthenticateError, EnvVar, IconOrSvg, InlineDescription, LanguageModel,
-    LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName,
-    LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,
-    LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice,
-    LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, ProviderSettingsView,
-    RateLimiter, Role, SubPageProviderSettings, TokenUsage, env_var,
+    LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelEffortLevel,
+    LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId,
+    LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest,
+    LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolSchemaFormat,
+    LanguageModelToolUse, MessageContent, ProviderSettingsView, RateLimiter, Role,
+    SubPageProviderSettings, TokenUsage, env_var,
 };
+use open_ai::responses::Request as OpenAiResponseRequest;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use settings::{BedrockAvailableModel as AvailableModel, Settings, SettingsStore};
+use settings::{
+    BedrockAvailableModel as AvailableModel, BedrockMantleAvailableModel as MantleAvailableModel,
+    Settings, SettingsStore,
+};
 use std::sync::LazyLock;
+use std::time::SystemTime;
 use strum::{EnumIter, IntoEnumIterator, IntoStaticStr};
 use ui::{ButtonLink, ConfiguredApiCard, Divider, List, ListBulletItem, prelude::*};
 use ui_input::InputField;
 use util::ResultExt;
 
 use crate::AllLanguageModelSettings;
-use http_client::CustomHeaders;
+use crate::provider::open_ai::{
+    ChatCompletionMaxTokensParameter, OpenAiEventMapper, OpenAiResponseEventMapper, into_open_ai,
+    into_open_ai_response,
+};
 use language_model::util::{fix_streamed_json, parse_tool_arguments};
+use open_ai::{ReasoningEffort, RequestError, ResponseStreamEvent};
 
 actions!(bedrock, [Tab, TabPrev]);
 
@@ -116,6 +135,7 @@ impl BedrockCredentials {
 #[derive(Default, Clone, Debug, PartialEq)]
 pub struct AmazonBedrockSettings {
     pub available_models: Vec<AvailableModel>,
+    pub mantle_available_models: Vec<MantleAvailableModel>,
     pub custom_headers: CustomHeaders,
     pub region: Option<String>,
     pub endpoint: Option<String>,
@@ -151,6 +171,13 @@ impl From<settings::BedrockAuthMethodContent> for BedrockAuthMethod {
     }
 }
 
+fn mantle_protocol_from_settings(value: settings::BedrockMantleProtocolContent) -> MantleProtocol {
+    match value {
+        settings::BedrockMantleProtocolContent::ChatCompletions => MantleProtocol::ChatCompletions,
+        settings::BedrockMantleProtocolContent::Responses => MantleProtocol::Responses,
+    }
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum ModelMode {
@@ -200,6 +227,115 @@ static ZED_BEDROCK_REGION_VAR: LazyLock<EnvVar> = env_var!("ZED_AWS_REGION");
 static ZED_AWS_ENDPOINT_VAR: LazyLock<EnvVar> = env_var!("ZED_AWS_ENDPOINT");
 static ZED_BEDROCK_BEARER_TOKEN_VAR: LazyLock<EnvVar> = env_var!("ZED_BEDROCK_BEARER_TOKEN");
 
+/// AWS Regions where the `bedrock-mantle` endpoint is available.
+/// See <https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html#regions>.
+const MANTLE_SUPPORTED_REGIONS: &[&str] = &[
+    "us-east-2",
+    "us-east-1",
+    "us-west-2",
+    "ap-southeast-3",
+    "ap-south-1",
+    "ap-southeast-2",
+    "ap-northeast-1",
+    "eu-central-1",
+    "eu-west-1",
+    "eu-west-2",
+    "eu-south-1",
+    "eu-north-1",
+    "sa-east-1",
+    "us-gov-west-1",
+];
+
+fn mantle_endpoint_url(region: &str) -> String {
+    format!("https://bedrock-mantle.{region}.api.aws/openai/v1")
+}
+
+enum MantleAuth {
+    ApiKey { api_key: String },
+    SigV4 { credentials: Credentials },
+}
+
+impl MantleAuth {
+    fn apply(&self, request: &mut HttpRequest<AsyncBody>, body: &[u8], region: &str) -> Result<()> {
+        match self {
+            MantleAuth::ApiKey { api_key } => {
+                let value = HeaderValue::from_str(&format!("Bearer {}", api_key.trim()))
+                    .context("building Mantle bearer token authorization header")?;
+                request.headers_mut().insert(AUTHORIZATION, value);
+            }
+            MantleAuth::SigV4 { credentials } => {
+                sign_mantle_request_sigv4(request, body, credentials, region)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+fn sign_mantle_request_sigv4(
+    request: &mut HttpRequest<AsyncBody>,
+    body: &[u8],
+    credentials: &Credentials,
+    region: &str,
+) -> Result<()> {
+    sign_mantle_request_sigv4_at(request, body, credentials, region, SystemTime::now())
+}
+
+fn sign_mantle_request_sigv4_at(
+    request: &mut HttpRequest<AsyncBody>,
+    body: &[u8],
+    credentials: &Credentials,
+    region: &str,
+    time: SystemTime,
+) -> Result<()> {
+    if !request
+        .headers()
+        .contains_key(http_client::http::header::HOST)
+        && let Some(authority) = request.uri().authority()
+    {
+        let host = HeaderValue::from_str(authority.as_str())
+            .context("invalid host header derived from Mantle request URI")?;
+        request
+            .headers_mut()
+            .insert(http_client::http::header::HOST, host);
+    }
+
+    let identity = credentials.clone().into();
+    let signing_params: aws_sigv4::http_request::SigningParams = v4::SigningParams::builder()
+        .identity(&identity)
+        .region(region)
+        .name("bedrock-mantle")
+        .time(time)
+        .settings(SigningSettings::default())
+        .build()
+        .context("building Mantle SigV4 signing params")?
+        .into();
+
+    let method = request.method().as_str();
+    let uri = request.uri().to_string();
+    let headers = request
+        .headers()
+        .iter()
+        .map(|(name, value)| {
+            value
+                .to_str()
+                .map(|value| (name.as_str(), value))
+                .with_context(|| format!("header {name} is not valid UTF-8 and cannot be signed"))
+        })
+        .collect::<Result<Vec<_>>>()?;
+
+    let signable_request =
+        SignableRequest::new(method, uri, headers.into_iter(), SignableBody::Bytes(body))
+            .context("constructing Mantle SigV4 request")?;
+
+    let (instructions, _signature) = sign(signable_request, &signing_params)
+        .context("signing Mantle request with SigV4")?
+        .into_parts();
+    instructions.apply_to_request_http1x(request);
+
+    Ok(())
+}
+
 pub struct State {
     /// The resolved authentication method. Settings take priority over UX credentials.
     auth: Option<BedrockAuth>,
@@ -407,6 +543,7 @@ impl State {
 
 pub struct BedrockLanguageModelProvider {
     http_client: AwsHttpClient,
+    plain_http_client: Arc<dyn HttpClient>,
     handle: tokio::runtime::Handle,
     state: Entity<State>,
 }
@@ -428,13 +565,14 @@ impl BedrockLanguageModelProvider {
         });
 
         Self {
-            http_client: AwsHttpClient::new(http_client),
+            http_client: AwsHttpClient::new(http_client.clone()),
+            plain_http_client: http_client,
             handle: Tokio::handle(cx),
             state,
         }
     }
 
-    fn create_language_model(&self, model: bedrock::Model) -> Arc<dyn LanguageModel> {
+    fn create_language_model(&self, model: bedrock::ConverseModel) -> Arc<dyn LanguageModel> {
         Arc::new(BedrockModel {
             id: LanguageModelId::from(model.id().to_string()),
             model,
@@ -445,6 +583,17 @@ impl BedrockLanguageModelProvider {
             request_limiter: RateLimiter::new(4),
         })
     }
+
+    fn create_mantle_language_model(&self, model: bedrock::MantleModel) -> Arc<dyn LanguageModel> {
+        Arc::new(BedrockMantleModel {
+            id: LanguageModelId::from(model.id().to_string()),
+            model,
+            http_client: self.plain_http_client.clone(),
+            state: self.state.clone(),
+            credentials_provider: Arc::new(OnceCell::new()),
+            request_limiter: RateLimiter::new(4),
+        })
+    }
 }
 
 impl LanguageModelProvider for BedrockLanguageModelProvider {
@@ -461,32 +610,29 @@ impl LanguageModelProvider for BedrockLanguageModelProvider {
     }
 
     fn default_model(&self, _cx: &App) -> Option<Arc<dyn LanguageModel>> {
-        Some(self.create_language_model(bedrock::Model::default()))
+        Some(self.create_language_model(bedrock::ConverseModel::default()))
     }
 
     fn default_fast_model(&self, cx: &App) -> Option<Arc<dyn LanguageModel>> {
         let region = self.state.read(cx).get_region();
-        Some(self.create_language_model(bedrock::Model::default_fast(region.as_str())))
+        Some(self.create_language_model(bedrock::ConverseModel::default_fast(region.as_str())))
     }
 
     fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {
+        let bedrock_settings = &AllLanguageModelSettings::get_global(cx).bedrock;
         let mut models = BTreeMap::default();
 
-        for model in bedrock::Model::iter() {
-            if !matches!(model, bedrock::Model::Custom { .. }) {
+        for model in bedrock::ConverseModel::iter() {
+            if !matches!(model, bedrock::ConverseModel::Custom { .. }) {
                 models.insert(model.id().to_string(), model);
             }
         }
 
         // Override with available models from settings
-        for model in AllLanguageModelSettings::get_global(cx)
-            .bedrock
-            .available_models
-            .iter()
-        {
+        for model in bedrock_settings.available_models.iter() {
             models.insert(
                 model.name.clone(),
-                bedrock::Model::Custom {
+                bedrock::ConverseModel::Custom {
                     name: model.name.clone(),
                     display_name: model.display_name.clone(),
                     max_tokens: model.max_tokens,
@@ -502,10 +648,43 @@ impl LanguageModelProvider for BedrockLanguageModelProvider {
             );
         }
 
-        models
+        let mut models: Vec<Arc<dyn LanguageModel>> = models
             .into_values()
             .map(|model| self.create_language_model(model))
-            .collect()
+            .collect();
+
+        let mut mantle_models = BTreeMap::default();
+
+        for model in bedrock::MantleModel::iter() {
+            if !matches!(model, bedrock::MantleModel::Custom { .. }) {
+                mantle_models.insert(model.id().to_string(), model);
+            }
+        }
+
+        // Override with available Mantle models from settings
+        for model in bedrock_settings.mantle_available_models.iter() {
+            mantle_models.insert(
+                model.name.clone(),
+                bedrock::MantleModel::Custom {
+                    name: model.name.clone(),
+                    display_name: model.display_name.clone(),
+                    max_tokens: model.max_tokens,
+                    max_output_tokens: model.max_output_tokens,
+                    protocol: mantle_protocol_from_settings(model.protocol),
+                    supports_tools: model.supports_tools.unwrap_or(false),
+                    supports_images: model.supports_images.unwrap_or(false),
+                    supports_thinking: model.supports_thinking.unwrap_or(false),
+                },
+            );
+        }
+
+        models.extend(
+            mantle_models
+                .into_values()
+                .map(|model| self.create_mantle_language_model(model)),
+        );
+
+        models
     }
 
     fn is_authenticated(&self, cx: &App) -> bool {
@@ -524,7 +703,7 @@ impl LanguageModelProvider for BedrockLanguageModelProvider {
                     .into()
             })
             .description(InlineDescription::Text(
-                "To use Zed's agent with Bedrock, set a custom authentication strategy in your settings or use static credentials.".into(),
+                "To use Zed's agent with Bedrock, set a custom authentication strategy in your settings or use static credentials. Mantle-only models (e.g. GPT-5.5, GPT-5.4, Grok 4.3) additionally require IAM permissions for the `bedrock-mantle` endpoint.".into(),
             )),
         ))
     }
@@ -540,7 +719,7 @@ impl LanguageModelProviderState for BedrockLanguageModelProvider {
 
 struct BedrockModel {
     id: LanguageModelId,
-    model: Model,
+    model: ConverseModel,
     http_client: AwsHttpClient,
     handle: tokio::runtime::Handle,
     client: OnceCell<BedrockClient>,
@@ -840,6 +1019,485 @@ impl LanguageModel for BedrockModel {
     }
 }
 
+const MANTLE_SELECTABLE_REASONING_EFFORTS: &[ReasoningEffort] = &[
+    ReasoningEffort::Low,
+    ReasoningEffort::Medium,
+    ReasoningEffort::High,
+    ReasoningEffort::XHigh,
+];
+
+fn mantle_default_reasoning_effort(model: &MantleModel) -> Option<ReasoningEffort> {
+    model.supports_thinking().then_some(ReasoningEffort::Medium)
+}
+
+fn mantle_selected_reasoning_effort(
+    request: &LanguageModelRequest,
+    model: &MantleModel,
+) -> Option<ReasoningEffort> {
+    if !model.supports_thinking() {
+        return None;
+    }
+
+    if request.thinking_allowed {
+        request
+            .thinking_effort
+            .as_deref()
+            .and_then(|effort| effort.parse::<ReasoningEffort>().ok())
+            .filter(|effort| *effort != ReasoningEffort::None)
+            .or_else(|| mantle_default_reasoning_effort(model))
+    } else {
+        Some(ReasoningEffort::None)
+    }
+}
+
+fn mantle_supported_effort_levels(model: &MantleModel) -> Vec<LanguageModelEffortLevel> {
+    let Some(default_effort) = mantle_default_reasoning_effort(model) else {
+        return Vec::new();
+    };
+
+    MANTLE_SELECTABLE_REASONING_EFFORTS
+        .iter()
+        .copied()
+        .map(|effort| LanguageModelEffortLevel {
+            name: effort.label().into(),
+            value: effort.value().into(),
+            is_default: effort == default_effort,
+        })
+        .collect()
+}
+
+/// Special-cases Mantle authorization failures with a message that points at
+/// the separate `bedrock-mantle` IAM policy namespace instead of regular
+/// `bedrock-runtime` permissions.
+fn map_mantle_error(model: &MantleModel, error: RequestError) -> LanguageModelCompletionError {
+    if let RequestError::HttpResponseError { status_code, .. } = &error
+        && *status_code == http_client::http::StatusCode::FORBIDDEN
+    {
+        return LanguageModelCompletionError::PermissionError {
+            provider: PROVIDER_NAME,
+            message: format!(
+                "Bedrock Mantle denied this request for {}. Mantle-only models require IAM \
+                 permissions for the `bedrock-mantle` endpoint (for example via the \
+                 `AmazonBedrockMantleInferenceAccess` managed policy) in addition to whatever \
+                 permissions your existing Bedrock credentials already have.",
+                model.display_name()
+            ),
+        };
+    }
+    error.into()
+}
+
+/// Resolves an AWS credentials provider for profile/SSO/automatic auth.
+/// Cached in `cell` since building it may read config files from disk;
+/// credentials themselves are still re-resolved on every call. Async so this
+/// never blocks the foreground thread (unlike `BedrockModel::get_or_init_client`).
+async fn resolve_mantle_credentials_provider(
+    cell: &OnceCell<SharedCredentialsProvider>,
+    profile_name: Option<String>,
+    region: String,
+) -> Result<SharedCredentialsProvider> {
+    let provider = cell
+        .get_or_try_init(move || async move {
+            let mut config_builder =
+                aws_config::defaults(BehaviorVersion::latest()).region(Region::new(region));
+
+            if let Some(profile_name) = profile_name.filter(|name| !name.is_empty()) {
+                config_builder = config_builder.profile_name(profile_name);
+            }
+
+            let config = config_builder.load().await;
+            config
+                .credentials_provider()
+                .context("no AWS credentials provider is configured")
+        })
+        .await
+        .context("resolving AWS credentials for Bedrock Mantle")?;
+    Ok(provider.clone())
+}
+
+/// Resolves provider settings into concrete Mantle request auth. A configured
+/// Bedrock API key is sent as bearer auth; every AWS-credential-based method
+/// signs the Mantle HTTP request directly with SigV4.
+async fn resolve_mantle_auth(
+    credentials_provider: Arc<OnceCell<SharedCredentialsProvider>>,
+    auth: Option<BedrockAuth>,
+    region: String,
+) -> Result<MantleAuth> {
+    match auth {
+        Some(BedrockAuth::ApiKey { api_key }) => Ok(MantleAuth::ApiKey { api_key }),
+        Some(BedrockAuth::IamCredentials {
+            access_key_id,
+            secret_access_key,
+            session_token,
+        }) => Ok(MantleAuth::SigV4 {
+            credentials: Credentials::new(
+                access_key_id,
+                secret_access_key,
+                session_token,
+                None,
+                "zed-bedrock-provider",
+            ),
+        }),
+        Some(BedrockAuth::NamedProfile { profile_name })
+        | Some(BedrockAuth::SingleSignOn { profile_name }) => {
+            let provider = resolve_mantle_credentials_provider(
+                &credentials_provider,
+                Some(profile_name),
+                region.clone(),
+            )
+            .await?;
+            let credentials = provider
+                .provide_credentials()
+                .await
+                .context("failed to resolve AWS credentials")?;
+            Ok(MantleAuth::SigV4 { credentials })
+        }
+        Some(BedrockAuth::Automatic) | None => {
+            let provider =
+                resolve_mantle_credentials_provider(&credentials_provider, None, region.clone())
+                    .await?;
+            let credentials = provider
+                .provide_credentials()
+                .await
+                .context("failed to resolve AWS credentials")?;
+            Ok(MantleAuth::SigV4 { credentials })
+        }
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum MantleChatStreamResult {
+    Ok(ResponseStreamEvent),
+    Err { error: MantleChatStreamError },
+}
+
+#[derive(Deserialize)]
+struct MantleChatStreamError {
+    message: String,
+}
+
+fn parse_mantle_chat_stream_line(line: &str) -> Result<ResponseStreamEvent> {
+    match serde_json::from_str(line) {
+        Ok(MantleChatStreamResult::Ok(response)) => Ok(response),
+        Ok(MantleChatStreamResult::Err { error }) => Err(anyhow!(error.message)),
+        Err(error) => {
+            log::error!(
+                "Failed to parse Mantle chat completion stream event: `{}`\nResponse: `{}`",
+                error,
+                line,
+            );
+            Err(anyhow!(error))
+        }
+    }
+}
+
+fn parse_mantle_response_stream_line(line: &str) -> Result<open_ai::responses::StreamEvent> {
+    serde_json::from_str(line).map_err(|error| {
+        log::error!(
+            "Failed to parse Mantle responses stream event: `{}`\nResponse: `{}`",
+            error,
+            line,
+        );
+        anyhow!(error)
+    })
+}
+
+async fn stream_mantle_sse<Request, Event>(
+    client: &dyn HttpClient,
+    provider_name: &str,
+    url: &str,
+    region: &str,
+    auth: &MantleAuth,
+    request: Request,
+    extra_headers: &CustomHeaders,
+    parse_stream_line: fn(&str) -> Result<Event>,
+) -> std::result::Result<BoxStream<'static, Result<Event>>, RequestError>
+where
+    Request: Serialize,
+    Event: Send + 'static,
+{
+    let body = serde_json::to_vec(&request).map_err(|error| RequestError::Other(error.into()))?;
+    let mut request = HttpRequest::builder()
+        .method(Method::POST)
+        .uri(url)
+        .header("Content-Type", "application/json")
+        .extra_headers(extra_headers)
+        .body(AsyncBody::from(body.clone()))
+        .map_err(|error| RequestError::Other(error.into()))?;
+
+    auth.apply(&mut request, &body, region)
+        .map_err(RequestError::Other)?;
+
+    let mut response = client.send(request).await?;
+    if response.status().is_success() {
+        let reader = BufReader::new(response.into_body());
+        Ok(reader
+            .lines()
+            .filter_map(move |line| async move {
+                match line {
+                    Ok(line) => {
+                        let line = line
+                            .strip_prefix("data: ")
+                            .or_else(|| line.strip_prefix("data:"))?;
+                        if line == "[DONE]" || line.is_empty() {
+                            None
+                        } else {
+                            Some(parse_stream_line(line))
+                        }
+                    }
+                    Err(error) => Some(Err(anyhow!(error))),
+                }
+            })
+            .boxed())
+    } else {
+        let mut body = String::new();
+        response
+            .body_mut()
+            .read_to_string(&mut body)
+            .await
+            .map_err(|error| RequestError::Other(error.into()))?;
+
+        Err(RequestError::HttpResponseError {
+            provider: provider_name.to_owned(),
+            status_code: response.status(),
+            body,
+            headers: response.headers().clone(),
+        })
+    }
+}
+
+fn strip_unsupported_mantle_response_fields(request: &mut OpenAiResponseRequest) {
+    request.context_management = None;
+}
+
+struct BedrockMantleModel {
+    id: LanguageModelId,
+    model: MantleModel,
+    http_client: Arc<dyn HttpClient>,
+    state: Entity<State>,
+    credentials_provider: Arc<OnceCell<SharedCredentialsProvider>>,
+    request_limiter: RateLimiter,
+}
+
+impl BedrockMantleModel {
+    fn stream_mantle_request<Request, Event>(
+        &self,
+        request: Request,
+        cx: &AsyncApp,
+        endpoint: &'static str,
+        parse_stream_line: fn(&str) -> Result<Event>,
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<Event>>, LanguageModelCompletionError>>
+    where
+        Request: Serialize + Send + 'static,
+        Event: Send + 'static,
+    {
+        let http_client = self.http_client.clone();
+        let model = self.model.clone();
+        let credentials_provider = self.credentials_provider.clone();
+        let (auth, region) = cx.read_entity(&self.state, |state, _cx| {
+            (state.auth.clone(), state.get_region())
+        });
+        let url = format!("{}/{}", mantle_endpoint_url(&region), endpoint);
+        let extra_headers = cx.read_entity(&self.state, |_, cx| {
+            AllLanguageModelSettings::get_global(cx)
+                .bedrock
+                .custom_headers
+                .clone()
+        });
+        let provider_name = PROVIDER_NAME.0.to_string();
+        let auth_task = Tokio::spawn_result(
+            cx,
+            resolve_mantle_auth(credentials_provider, auth, region.clone()),
+        );
+
+        let future = self.request_limiter.stream(async move {
+            let auth = auth_task
+                .await
+                .map_err(LanguageModelCompletionError::Other)?;
+            stream_mantle_sse(
+                http_client.as_ref(),
+                &provider_name,
+                &url,
+                &region,
+                &auth,
+                request,
+                &extra_headers,
+                parse_stream_line,
+            )
+            .await
+            .map_err(|err| map_mantle_error(&model, err))
+        });
+
+        async move { Ok(future.await?.boxed()) }.boxed()
+    }
+
+    fn stream_completion(
+        &self,
+        request: open_ai::Request,
+        cx: &AsyncApp,
+    ) -> BoxFuture<
+        'static,
+        Result<BoxStream<'static, Result<ResponseStreamEvent>>, LanguageModelCompletionError>,
+    > {
+        self.stream_mantle_request(
+            request,
+            cx,
+            "chat/completions",
+            parse_mantle_chat_stream_line,
+        )
+    }
+
+    fn stream_response(
+        &self,
+        request: OpenAiResponseRequest,
+        cx: &AsyncApp,
+    ) -> BoxFuture<
+        'static,
+        Result<
+            BoxStream<'static, Result<open_ai::responses::StreamEvent>>,
+            LanguageModelCompletionError,
+        >,
+    > {
+        let mut request = request;
+        strip_unsupported_mantle_response_fields(&mut request);
+        self.stream_mantle_request(request, cx, "responses", parse_mantle_response_stream_line)
+    }
+}
+
+impl LanguageModel for BedrockMantleModel {
+    fn id(&self) -> LanguageModelId {
+        self.id.clone()
+    }
+
+    fn name(&self) -> LanguageModelName {
+        LanguageModelName::from(self.model.display_name().to_string())
+    }
+
+    fn provider_id(&self) -> LanguageModelProviderId {
+        PROVIDER_ID
+    }
+
+    fn provider_name(&self) -> LanguageModelProviderName {
+        PROVIDER_NAME
+    }
+
+    fn supports_tools(&self) -> bool {
+        self.model.supports_tools()
+    }
+
+    fn tool_input_format(&self) -> LanguageModelToolSchemaFormat {
+        LanguageModelToolSchemaFormat::JsonSchemaSubset
+    }
+
+    fn supports_images(&self) -> bool {
+        self.model.supports_images()
+    }
+
+    fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool {
+        match choice {
+            LanguageModelToolChoice::Auto | LanguageModelToolChoice::Any => {
+                self.model.supports_tools()
+            }
+            LanguageModelToolChoice::None => true,
+        }
+    }
+
+    fn supports_streaming_tools(&self) -> bool {
+        true
+    }
+
+    fn supports_thinking(&self) -> bool {
+        self.model.supports_thinking()
+    }
+
+    fn supported_effort_levels(&self) -> Vec<LanguageModelEffortLevel> {
+        mantle_supported_effort_levels(&self.model)
+    }
+
+    fn supports_split_token_display(&self) -> bool {
+        true
+    }
+
+    fn telemetry_id(&self) -> String {
+        format!("bedrock-mantle/{}", self.model.id())
+    }
+
+    fn max_token_count(&self) -> u64 {
+        self.model.max_token_count()
+    }
+
+    fn max_output_tokens(&self) -> Option<u64> {
+        Some(self.model.max_output_tokens())
+    }
+
+    fn stream_completion(
+        &self,
+        request: LanguageModelRequest,
+        cx: &AsyncApp,
+    ) -> BoxFuture<
+        'static,
+        Result<
+            BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
+            LanguageModelCompletionError,
+        >,
+    > {
+        let region = cx.read_entity(&self.state, |state, _cx| state.get_region());
+
+        if !MANTLE_SUPPORTED_REGIONS.contains(&region.as_str()) {
+            let display_name = self.model.display_name().to_string();
+            let supported = MANTLE_SUPPORTED_REGIONS.join(", ");
+            return futures::future::ready(Err(LanguageModelCompletionError::Other(anyhow!(
+                "{display_name} is not available in {region} because Bedrock Mantle isn't offered \
+                 there. Try switching to one of the following regions: {supported}."
+            ))))
+            .boxed();
+        }
+
+        let model_id = self.model.request_id().to_string();
+        let max_output_tokens = Some(self.model.max_output_tokens());
+
+        match self.model.protocol() {
+            MantleProtocol::Responses => {
+                let request = into_open_ai_response(
+                    request,
+                    &model_id,
+                    self.model.supports_tools(),
+                    false,
+                    max_output_tokens,
+                    mantle_default_reasoning_effort(&self.model),
+                    self.model.supports_thinking(),
+                );
+                let completions = self.stream_response(request, cx);
+                async move {
+                    let mapper = OpenAiResponseEventMapper::new();
+                    Ok(mapper.map_stream(completions.await?).boxed())
+                }
+                .boxed()
+            }
+            MantleProtocol::ChatCompletions => {
+                let reasoning_effort = mantle_selected_reasoning_effort(&request, &self.model);
+                let request = into_open_ai(
+                    request,
+                    &model_id,
+                    self.model.supports_tools(),
+                    false,
+                    max_output_tokens,
+                    ChatCompletionMaxTokensParameter::MaxCompletionTokens,
+                    reasoning_effort,
+                    false,
+                );
+                let completions = self.stream_completion(request, cx);
+                async move {
+                    let mapper = OpenAiEventMapper::new();
+                    Ok(mapper.map_stream(completions.await?).boxed())
+                }
+                .boxed()
+            }
+        }
+    }
+}
+
 fn deny_tool_use_events(
     events: impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
 ) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
@@ -895,7 +1553,7 @@ pub fn into_bedrock(
                         }
                         MessageContent::Compaction(_) => None,
                         MessageContent::Thinking { text, signature } => {
-                            if model.contains(Model::DeepSeekR1.request_id()) {
+                            if model.contains(ConverseModel::DeepSeekR1.request_id()) {
                                 // DeepSeekR1 doesn't support thinking blocks
                                 // And the AWS API demands that you strip them
                                 return None;
@@ -918,7 +1576,7 @@ pub fn into_bedrock(
                             ))
                         }
                         MessageContent::RedactedThinking(blob) => {
-                            if model.contains(Model::DeepSeekR1.request_id()) {
+                            if model.contains(ConverseModel::DeepSeekR1.request_id()) {
                                 // DeepSeekR1 doesn't support thinking blocks
                                 // And the AWS API demands that you strip them
                                 return None;
@@ -1834,4 +2492,218 @@ mod tests {
             "a cache-marked message with content should end with a cache point"
         );
     }
+
+    #[test]
+    fn test_sign_mantle_request_sigv4_uses_mantle_service() {
+        let credentials = Credentials::new(
+            "AKIDEXAMPLE",
+            "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY",
+            None,
+            None,
+            "test",
+        );
+        let body = br#"{"model":"openai.gpt-5.5"}"#;
+        let mut request = HttpRequest::builder()
+            .method(Method::POST)
+            .uri("https://bedrock-mantle.us-east-1.api.aws/openai/v1/responses")
+            .header("Content-Type", "application/json")
+            .body(AsyncBody::from(body.to_vec()))
+            .unwrap();
+        let time = std::time::UNIX_EPOCH + std::time::Duration::from_secs(1_700_000_000);
+
+        sign_mantle_request_sigv4_at(&mut request, body, &credentials, "us-east-1", time).unwrap();
+
+        assert_eq!(
+            request
+                .headers()
+                .get(http_client::http::header::HOST)
+                .and_then(|value| value.to_str().ok()),
+            Some("bedrock-mantle.us-east-1.api.aws")
+        );
+        assert_eq!(
+            request
+                .headers()
+                .get("x-amz-date")
+                .and_then(|value| value.to_str().ok()),
+            Some("20231114T221320Z")
+        );
+        let authorization = request
+            .headers()
+            .get(AUTHORIZATION)
+            .and_then(|value| value.to_str().ok())
+            .unwrap();
+        assert!(authorization.starts_with("AWS4-HMAC-SHA256 "));
+        assert!(
+            authorization
+                .contains("Credential=AKIDEXAMPLE/20231114/us-east-1/bedrock-mantle/aws4_request")
+        );
+        assert!(authorization.contains("SignedHeaders=content-type;host"));
+        assert!(authorization.contains("Signature="));
+    }
+
+    #[test]
+    fn test_mantle_endpoint_url_uses_openai_path_prefix() {
+        assert_eq!(
+            mantle_endpoint_url("us-east-1"),
+            "https://bedrock-mantle.us-east-1.api.aws/openai/v1"
+        );
+        assert_eq!(
+            mantle_endpoint_url("us-west-2"),
+            "https://bedrock-mantle.us-west-2.api.aws/openai/v1"
+        );
+    }
+
+    #[test]
+    fn test_mantle_protocol_from_settings() {
+        assert_eq!(
+            mantle_protocol_from_settings(settings::BedrockMantleProtocolContent::ChatCompletions),
+            MantleProtocol::ChatCompletions
+        );
+        assert_eq!(
+            mantle_protocol_from_settings(settings::BedrockMantleProtocolContent::Responses),
+            MantleProtocol::Responses
+        );
+    }
+
+    #[test]
+    fn test_mantle_supported_regions_matches_docs() {
+        assert!(MANTLE_SUPPORTED_REGIONS.contains(&"us-east-1"));
+        assert!(MANTLE_SUPPORTED_REGIONS.contains(&"eu-west-1"));
+        assert!(!MANTLE_SUPPORTED_REGIONS.contains(&"ap-southeast-1"));
+    }
+
+    #[test]
+    fn test_builtin_mantle_models_support_thinking() {
+        assert!(MantleModel::Gpt5_5.supports_thinking());
+        assert!(MantleModel::Gpt5_4.supports_thinking());
+        assert!(MantleModel::Grok4_3.supports_thinking());
+        assert_eq!(
+            mantle_default_reasoning_effort(&MantleModel::Gpt5_5),
+            Some(ReasoningEffort::Medium)
+        );
+        assert_eq!(
+            mantle_default_reasoning_effort(&MantleModel::Grok4_3),
+            Some(ReasoningEffort::Medium)
+        );
+    }
+
+    #[test]
+    fn test_mantle_supported_effort_levels_hide_none() {
+        let effort_levels = mantle_supported_effort_levels(&MantleModel::Gpt5_5);
+        let values = effort_levels
+            .iter()
+            .map(|level| level.value.as_ref())
+            .collect::<Vec<_>>();
+
+        assert_eq!(values, ["low", "medium", "high", "xhigh"]);
+        assert_eq!(
+            effort_levels
+                .iter()
+                .find(|level| level.is_default)
+                .map(|level| level.value.as_ref()),
+            Some("medium")
+        );
+    }
+
+    #[test]
+    fn test_custom_mantle_model_can_disable_thinking() {
+        let model = MantleModel::Custom {
+            name: "custom-mantle-model".to_string(),
+            display_name: None,
+            max_tokens: 128_000,
+            max_output_tokens: None,
+            protocol: MantleProtocol::Responses,
+            supports_tools: true,
+            supports_images: false,
+            supports_thinking: false,
+        };
+
+        assert!(!model.supports_thinking());
+        assert_eq!(mantle_default_reasoning_effort(&model), None);
+        assert!(mantle_supported_effort_levels(&model).is_empty());
+        assert_eq!(
+            mantle_selected_reasoning_effort(
+                &LanguageModelRequest {
+                    thinking_effort: Some("high".to_string()),
+                    ..Default::default()
+                },
+                &model,
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn test_disabled_mantle_thinking_serializes_none() {
+        let request = into_open_ai_response(
+            LanguageModelRequest {
+                thinking_allowed: false,
+                ..Default::default()
+            },
+            MantleModel::Grok4_3.request_id(),
+            true,
+            false,
+            Some(MantleModel::Grok4_3.max_output_tokens()),
+            mantle_default_reasoning_effort(&MantleModel::Grok4_3),
+            MantleModel::Grok4_3.supports_thinking(),
+        );
+
+        assert_eq!(
+            serde_json::to_value(&request).unwrap()["reasoning"],
+            serde_json::json!({ "effort": "none" })
+        );
+    }
+
+    #[test]
+    fn test_mantle_reasoning_passes_known_efforts_through() {
+        for effort in ["low", "medium", "high", "xhigh", "minimal", "max"] {
+            assert_eq!(
+                mantle_selected_reasoning_effort(
+                    &LanguageModelRequest {
+                        thinking_allowed: true,
+                        thinking_effort: Some(effort.to_string()),
+                        ..Default::default()
+                    },
+                    &MantleModel::Gpt5_5,
+                )
+                .map(|effort| effort.value()),
+                Some(effort)
+            );
+        }
+
+        assert_eq!(
+            mantle_selected_reasoning_effort(
+                &LanguageModelRequest {
+                    thinking_allowed: true,
+                    thinking_effort: Some("none".to_string()),
+                    ..Default::default()
+                },
+                &MantleModel::Gpt5_5,
+            ),
+            Some(ReasoningEffort::Medium)
+        );
+    }
+
+    #[test]
+    fn test_strip_unsupported_mantle_response_fields_removes_context_management() {
+        let mut request = into_open_ai_response(
+            LanguageModelRequest {
+                compact_at_tokens: Some(10_000),
+                ..Default::default()
+            },
+            "openai.gpt-5.5",
+            true,
+            false,
+            Some(128_000),
+            Some(ReasoningEffort::Medium),
+            false,
+        );
+
+        assert!(request.context_management.is_some());
+        strip_unsupported_mantle_response_fields(&mut request);
+        assert!(request.context_management.is_none());
+
+        let request = serde_json::to_value(&request).unwrap();
+        assert!(request.get("context_management").is_none());
+    }
 }
diff --git a/crates/language_models/src/settings.rs b/crates/language_models/src/settings.rs
index 1ce7caa3a67..4f360eea95c 100644
--- a/crates/language_models/src/settings.rs
+++ b/crates/language_models/src/settings.rs
@@ -95,6 +95,7 @@ impl settings::Settings for AllLanguageModelSettings {
                 .collect(),
             bedrock: AmazonBedrockSettings {
                 available_models: bedrock.available_models.unwrap_or_default(),
+                mantle_available_models: bedrock.mantle_available_models.unwrap_or_default(),
                 custom_headers: custom_headers_from(
                     "Amazon Bedrock",
                     bedrock.custom_headers,
diff --git a/crates/open_ai/src/completion.rs b/crates/open_ai/src/completion.rs
index f39a9af218f..0638203d769 100644
--- a/crates/open_ai/src/completion.rs
+++ b/crates/open_ai/src/completion.rs
@@ -814,7 +814,8 @@ impl OpenAiResponseEventMapper {
                 }
                 events
             }
-            ResponsesStreamEvent::ReasoningSummaryTextDelta { delta, .. } => {
+            ResponsesStreamEvent::ReasoningSummaryTextDelta { delta, .. }
+            | ResponsesStreamEvent::ReasoningDelta { delta, .. } => {
                 if delta.is_empty() {
                     Vec::new()
                 } else {
@@ -973,6 +974,7 @@ impl OpenAiResponseEventMapper {
             | ResponsesStreamEvent::ContentPartDone { .. }
             | ResponsesStreamEvent::ReasoningSummaryTextDone { .. }
             | ResponsesStreamEvent::ReasoningSummaryPartDone { .. }
+            | ResponsesStreamEvent::ReasoningDone { .. }
             | ResponsesStreamEvent::Created { .. }
             | ResponsesStreamEvent::InProgress { .. }
             | ResponsesStreamEvent::Unknown => Vec::new(),
@@ -1371,6 +1373,22 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn responses_stream_maps_mantle_reasoning_delta() {
+        let event = serde_json::from_value::<ResponsesStreamEvent>(json!({
+            "type": "response.reasoning.delta",
+            "delta": "checking the contract terms"
+        }))
+        .unwrap();
+
+        let mapped = map_response_events(vec![event]);
+        assert!(matches!(
+            &mapped[0],
+            LanguageModelCompletionEvent::Thinking { text, signature: None }
+                if text == "checking the contract terms"
+        ));
+    }
+
     #[test]
     fn response_usage_deserializes_cached_tokens() -> Result<()> {
         let usage: ResponseUsage = serde_json::from_value(json!({
diff --git a/crates/open_ai/src/responses.rs b/crates/open_ai/src/responses.rs
index 647f9fcbace..33ec1dfba46 100644
--- a/crates/open_ai/src/responses.rs
+++ b/crates/open_ai/src/responses.rs
@@ -310,6 +310,23 @@ pub enum StreamEvent {
         output_index: usize,
         summary_index: usize,
     },
+    #[serde(rename = "response.reasoning.delta")]
+    ReasoningDelta {
+        #[serde(default)]
+        item_id: Option<String>,
+        #[serde(default)]
+        output_index: Option<usize>,
+        delta: String,
+    },
+    #[serde(rename = "response.reasoning.done")]
+    ReasoningDone {
+        #[serde(default)]
+        item_id: Option<String>,
+        #[serde(default)]
+        output_index: Option<usize>,
+        #[serde(default)]
+        text: Option<String>,
+    },
     #[serde(rename = "response.function_call_arguments.delta")]
     FunctionCallArgumentsDelta {
         item_id: String,
diff --git a/crates/settings_content/src/language_model.rs b/crates/settings_content/src/language_model.rs
index f61d80ead75..5abc65dc805 100644
--- a/crates/settings_content/src/language_model.rs
+++ b/crates/settings_content/src/language_model.rs
@@ -114,6 +114,10 @@ pub struct AnthropicAvailableModel {
 #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema, MergeFrom)]
 pub struct AmazonBedrockSettingsContent {
     pub available_models: Option<Vec<BedrockAvailableModel>>,
+    /// Custom models served through the `bedrock-mantle` endpoint's
+    /// OpenAI-compatible APIs, in addition to the built-in Mantle models
+    /// (GPT-5.5, GPT-5.4, Grok 4.3).
+    pub mantle_available_models: Option<Vec<BedrockMantleAvailableModel>>,
     pub custom_headers: Option<HashMap<String, String>>,
     pub endpoint_url: Option<String>,
     pub region: Option<String>,
@@ -139,6 +143,32 @@ pub struct BedrockAvailableModel {
     pub mode: Option<ModelMode>,
 }
 
+#[with_fallible_options]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema, MergeFrom)]
+pub struct BedrockMantleAvailableModel {
+    /// The model id as expected in Bedrock Mantle request bodies, e.g. `openai.gpt-5.5`.
+    pub name: String,
+    pub display_name: Option<String>,
+    pub max_tokens: u64,
+    pub max_output_tokens: Option<u64>,
+    /// The OpenAI-compatible API this model must be called through.
+    pub protocol: BedrockMantleProtocolContent,
+    pub supports_tools: Option<bool>,
+    pub supports_images: Option<bool>,
+    /// Whether this custom Mantle model supports OpenAI reasoning effort parameters.
+    pub supports_thinking: Option<bool>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, JsonSchema, MergeFrom)]
+pub enum BedrockMantleProtocolContent {
+    /// The OpenAI Chat Completions API (`/chat/completions`).
+    #[serde(rename = "chat_completions")]
+    ChatCompletions,
+    /// The OpenAI Responses API (`/responses`).
+    #[serde(rename = "responses")]
+    Responses,
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema, MergeFrom)]
 pub enum BedrockAuthMethodContent {
     #[serde(rename = "named_profile")]
diff --git a/docs/src/ai/use-a-gateway.md b/docs/src/ai/use-a-gateway.md
index e010cfe8159..6cd1a7a614d 100644
--- a/docs/src/ai/use-a-gateway.md
+++ b/docs/src/ai/use-a-gateway.md
@@ -213,6 +213,38 @@ Some AWS environments require a guardrail on every Bedrock API call. Add `guardr
 }
 ```
 
+### Bedrock Mantle Models {#bedrock-mantle-models}
+
+Some models, such as GPT-5.5, GPT-5.4, and Grok 4.3, aren't available through Bedrock's Converse API and are only reachable through `bedrock-mantle`, AWS's OpenAI-compatible inference endpoint. Zed routes these models through `bedrock-mantle` automatically; they appear alongside the rest of the Bedrock models in the model picker once you're authenticated, with no extra configuration required.
+
+Mantle models require IAM permissions for the `bedrock-mantle` endpoint (for example via the `AmazonBedrockMantleInferenceAccess` managed policy) in addition to whatever permissions your existing Bedrock credentials already have, and `bedrock-mantle` is only available in [some AWS Regions](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html#regions). Zed surfaces an error naming the current Region and the supported ones if you try to use a Mantle model outside of them.
+
+#### Custom Bedrock Mantle Models {#bedrock-mantle-custom-models}
+
+You can add custom models served through `bedrock-mantle` with `mantle_available_models`:
+
+```json [settings]
+{
+  "language_models": {
+    "bedrock": {
+      "mantle_available_models": [
+        {
+          "name": "openai.gpt-oss-120b",
+          "display_name": "GPT-OSS 120B",
+          "max_tokens": 128000,
+          "protocol": "chat_completions",
+          "supports_tools": true,
+          "supports_images": false,
+          "supports_thinking": true
+        }
+      ]
+    }
+  }
+}
+```
+
+`protocol` selects which OpenAI-compatible API the model is called through, and must be either `chat_completions` or `responses`. Set `supports_thinking` to `true` for custom Mantle models that accept OpenAI reasoning effort parameters; Zed will then expose `low`, `medium`, `high`, and `xhigh` in the thinking effort picker, while disabling thinking sends `none`.
+
 ## OpenAI-Compatible Gateways {#openai-compatible}
 
 If your gateway exposes an OpenAI-compatible API, configure it with [Use API Access](./use-api-access.md#openai-compatible).