Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

193 KB
Raw Blame
use std::pin::Pin;
use std::sync::Arc;

use anyhow::{Context as _, Result, anyhow};
use aws_config::stalled_stream_protection::StalledStreamProtectionConfig;
use aws_config::{BehaviorVersion, Region};
use aws_credential_types::provider::ProvideCredentials;
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;
use bedrock::bedrock_client::types::{
    CachePointBlock, CachePointType, ContentBlockDelta, ContentBlockStart, ConverseStreamOutput,
    ReasoningContentBlockDelta, StopReason,
};
use bedrock::{
    BedrockAnyToolChoice, BedrockAutoToolChoice, BedrockBlob, BedrockError, BedrockImageBlock,
    BedrockImageFormat, BedrockImageSource, BedrockInnerContent, BedrockMessage, BedrockModelMode,
    BedrockStreamingResponse, BedrockThinkingBlock, BedrockThinkingTextBlock, BedrockTool,
    BedrockToolChoice, BedrockToolConfig, BedrockToolInputSchema, BedrockToolResultBlock,
    BedrockToolResultContentBlock, BedrockToolResultStatus, BedrockToolSpec, BedrockToolUseBlock,
    ConverseModel, MantleModel, MantleProtocol, value_to_aws_document,
};
use collections::{BTreeMap, HashMap, IndexMap};
use credentials_provider::CredentialsProvider;
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::{
    AsyncBody, CustomHeaders, HttpClient, Method, Request as HttpRequest, RequestBuilderExt,
    http::{HeaderValue, header::AUTHORIZATION},
};
use language_model::{
    AuthenticateError, EnvVar, IconOrSvg, InlineDescription, LanguageModel, LanguageModelClient,
    LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelCompletionStream,
    LanguageModelEffortLevel, LanguageModelId, LanguageModelName, LanguageModelProvider,
    LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState,
    LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolChoiceSupport,
    LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, ModelRateLimiters,
    ProviderErrorCategory, ProviderSettingsView, RateLimiter, Role, SubPageProviderSettings,
    TokenUsage, env_var, unavailable_error,
};
use open_ai::responses::Request as OpenAiResponseRequest;
use open_ai::responses::{ResponseOutputItem, StreamEvent as OpenAiResponseStreamEvent};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use settings::{
    BedrockAvailableModel as AvailableModel, BedrockMantleAvailableModel as MantleAvailableModel,
    Settings, SettingsStore,
};
use std::sync::LazyLock;
use std::time::{Duration, 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 crate::provider::open_ai::{
    ChatCompletionMaxTokensParameter, OpenAiResponseEventMapper, into_open_ai,
    into_open_ai_response,
};
use language_model::chat_completion::{
    ChatCompletionEventMapper, ResponseStreamEvent, ResponseStreamResult,
};
use language_model::util::{fix_streamed_json, parse_tool_arguments};
use open_ai::{ReasoningEffort, RequestError};

actions!(bedrock, [Tab, TabPrev]);

const PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("amazon-bedrock");
const PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new("Amazon Bedrock");
pub(crate) const RESERVED_HEADER_NAMES: &[&str] = &[
    "host",
    "x-amz-date",
    "x-amz-security-token",
    "x-amz-content-sha256",
    "amz-sdk-invocation-id",
    "amz-sdk-request",
];

/// Credentials stored in the keychain for static authentication.
/// Region is handled separately since it's orthogonal to auth method.
#[derive(Default, Clone, Deserialize, Serialize, PartialEq, Debug)]
pub struct BedrockCredentials {
    pub access_key_id: String,
    pub secret_access_key: String,
    pub session_token: Option<String>,
    pub bearer_token: Option<String>,
}

/// Resolved authentication configuration for Bedrock.
/// Settings take priority over UX-provided credentials.
#[derive(Clone, Debug, PartialEq)]
pub enum BedrockAuth {
    /// Use default AWS credential provider chain (IMDSv2, PodIdentity, env vars, etc.)
    Automatic,
    /// Use AWS named profile from ~/.aws/credentials or ~/.aws/config
    NamedProfile { profile_name: String },
    /// Use AWS SSO profile
    SingleSignOn { profile_name: String },
    /// Use IAM credentials (access key + secret + optional session token)
    IamCredentials {
        access_key_id: String,
        secret_access_key: String,
        session_token: Option<String>,
    },
    /// Use Bedrock API Key (bearer token authentication)
    ApiKey { api_key: String },
}

impl BedrockCredentials {
    /// Convert stored credentials to the appropriate auth variant.
    /// Prefers API key if present, otherwise uses IAM credentials.
    fn into_auth(self) -> Option<BedrockAuth> {
        if let Some(api_key) = self.bearer_token.filter(|t| !t.is_empty()) {
            Some(BedrockAuth::ApiKey { api_key })
        } else if !self.access_key_id.is_empty() && !self.secret_access_key.is_empty() {
            Some(BedrockAuth::IamCredentials {
                access_key_id: self.access_key_id,
                secret_access_key: self.secret_access_key,
                session_token: self.session_token.filter(|t| !t.is_empty()),
            })
        } else {
            None
        }
    }
}

#[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>,
    pub profile_name: Option<String>,
    pub role_arn: Option<String>,
    pub authentication_method: Option<BedrockAuthMethod>,
    pub allow_global: Option<bool>,
    pub guardrail_identifier: Option<String>,
    pub guardrail_version: Option<String>,
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, EnumIter, IntoStaticStr, JsonSchema)]
pub enum BedrockAuthMethod {
    #[serde(rename = "named_profile")]
    NamedProfile,
    #[serde(rename = "sso")]
    SingleSignOn,
    #[serde(rename = "api_key")]
    ApiKey,
    /// IMDSv2, PodIdentity, env vars, etc.
    #[serde(rename = "default")]
    Automatic,
}

impl From<settings::BedrockAuthMethodContent> for BedrockAuthMethod {
    fn from(value: settings::BedrockAuthMethodContent) -> Self {
        match value {
            settings::BedrockAuthMethodContent::SingleSignOn => BedrockAuthMethod::SingleSignOn,
            settings::BedrockAuthMethodContent::Automatic => BedrockAuthMethod::Automatic,
            settings::BedrockAuthMethodContent::NamedProfile => BedrockAuthMethod::NamedProfile,
            settings::BedrockAuthMethodContent::ApiKey => BedrockAuthMethod::ApiKey,
        }
    }
}

fn thinking_from_settings(
    thinking: Option<&settings::BedrockThinkingSettings>,
) -> Option<bedrock::BedrockThinkingConfig> {
    match thinking {
        None | Some(settings::BedrockThinkingSettings::Enabled(false)) => None,
        Some(settings::BedrockThinkingSettings::Enabled(true)) => {
            Some(bedrock::BedrockThinkingConfig {
                adaptive: false,
                has_xhigh: false,
                budget_tokens: None,
            })
        }
        Some(settings::BedrockThinkingSettings::Config(thinking)) => {
            Some(bedrock::BedrockThinkingConfig {
                adaptive: thinking.adaptive.unwrap_or(false),
                has_xhigh: thinking.has_xhigh.unwrap_or(false),
                budget_tokens: thinking.budget_tokens,
            })
        }
    }
}

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 {
    #[default]
    Default,
    Thinking {
        /// The maximum number of tokens to use for reasoning. Must be lower than the model's `max_output_tokens`.
        budget_tokens: Option<u64>,
    },
    AdaptiveThinking {
        effort: bedrock::BedrockAdaptiveThinkingEffort,
    },
    Reasoning {
        effort: bedrock::BedrockAdaptiveThinkingEffort,
    },
}

impl From<ModelMode> for BedrockModelMode {
    fn from(value: ModelMode) -> Self {
        match value {
            ModelMode::Default => BedrockModelMode::Default,
            ModelMode::Thinking { budget_tokens } => BedrockModelMode::Thinking { budget_tokens },
            ModelMode::AdaptiveThinking { effort } => BedrockModelMode::AdaptiveThinking { effort },
            ModelMode::Reasoning { effort } => BedrockModelMode::Reasoning { effort },
        }
    }
}

impl From<BedrockModelMode> for ModelMode {
    fn from(value: BedrockModelMode) -> Self {
        match value {
            BedrockModelMode::Default => ModelMode::Default,
            BedrockModelMode::Thinking { budget_tokens } => ModelMode::Thinking { budget_tokens },
            BedrockModelMode::AdaptiveThinking { effort } => ModelMode::AdaptiveThinking { effort },
            BedrockModelMode::Reasoning { effort } => ModelMode::Reasoning { effort },
        }
    }
}

/// The URL of the base AWS service.
///
/// Right now we're just using this as the key to store the AWS credentials
/// under in the keychain.
const AMAZON_AWS_URL: &str = "https://amazonaws.com";

// These environment variables all use a `ZED_` prefix because we don't want to overwrite the user's AWS credentials.
static ZED_BEDROCK_ACCESS_KEY_ID_VAR: LazyLock<EnvVar> = env_var!("ZED_ACCESS_KEY_ID");
static ZED_BEDROCK_SECRET_ACCESS_KEY_VAR: LazyLock<EnvVar> = env_var!("ZED_SECRET_ACCESS_KEY");
static ZED_BEDROCK_SESSION_TOKEN_VAR: LazyLock<EnvVar> = env_var!("ZED_SESSION_TOKEN");
static ZED_AWS_PROFILE_VAR: LazyLock<EnvVar> = env_var!("ZED_AWS_PROFILE");
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")
}

/// Auth resolved for one request, shared by the Converse and Mantle APIs.
#[derive(Clone)]
enum BedrockRequestAuth {
    ApiKey { api_key: String },
    SigV4 { credentials: Credentials },
}

impl BedrockRequestAuth {
    fn apply(&self, request: &mut HttpRequest<AsyncBody>, body: &[u8], region: &str) -> Result<()> {
        match self {
            BedrockRequestAuth::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);
            }
            BedrockRequestAuth::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>,
    /// Raw settings from settings.json
    settings: Option<AmazonBedrockSettings>,
    /// Whether credentials came from environment variables (only relevant for static credentials)
    credentials_from_env: bool,
    credentials_provider: Arc<dyn CredentialsProvider>,
    /// AWS credentials that expire, such as those from SSO, STS or a credential
    /// process, reused until shortly before they expire. Credentials without an
    /// expiry are resolved for every request instead, because the AWS SDK never
    /// rereads credential files and external tools rewrite them.
    expiring_credentials: Option<ExpiringCredentials>,
    /// Incremented on every auth change, so credentials resolved for earlier
    /// auth are not cached once they arrive.
    auth_generation: u64,
    _subscription: Subscription,
}

struct ExpiringCredentials {
    auth: Option<BedrockAuth>,
    region: String,
    credentials: Credentials,
}

/// How long before expiry cached AWS credentials are replaced, so a request
/// that streams for a while does not outlive them.
const CREDENTIALS_EXPIRY_MARGIN: Duration = Duration::from_secs(5 * 60);

/// How long resolving AWS credentials may take before the request fails,
/// matching the AWS SDK's default identity cache load timeout. Without it a
/// hung credential process or metadata endpoint would stall the request.
const CREDENTIALS_LOAD_TIMEOUT: Duration = Duration::from_secs(5);

/// The Bedrock bearer token the AWS SDK would find in the environment, looked
/// up with `environment_variable`.
///
/// Unless a token is configured explicitly, the SDK prefers this token over any
/// AWS credentials when it builds a client, so it is honored before resolving
/// credentials. Like the SDK, this checks the Bedrock-specific variable, then
/// the generic one, and uses a set value even when it is empty.
fn environment_bearer_token(
    environment_variable: impl Fn(&str) -> Option<String>,
) -> Option<String> {
    environment_variable("AWS_BEARER_TOKEN_BEDROCK")
        .or_else(|| environment_variable("AWS_BEARER_TOKEN"))
}

impl State {
    /// Sets the auth method and drops credentials resolved for the old one.
    fn set_auth(&mut self, auth: Option<BedrockAuth>) {
        self.auth = auth;
        self.expiring_credentials = None;
        self.auth_generation += 1;
    }

    fn reset_auth(&self, cx: &mut Context<Self>) -> Task<Result<()>> {
        let credentials_provider = self.credentials_provider.clone();
        cx.spawn(async move |this, cx| {
            credentials_provider
                .delete_credentials(AMAZON_AWS_URL, cx)
                .await
                .log_err();
            this.update(cx, |this, cx| {
                this.set_auth(None);
                this.credentials_from_env = false;
                cx.notify();
            })
        })
    }

    fn set_static_credentials(
        &mut self,
        credentials: BedrockCredentials,
        cx: &mut Context<Self>,
    ) -> Task<Result<()>> {
        let auth = credentials.clone().into_auth();
        let credentials_provider = self.credentials_provider.clone();
        cx.spawn(async move |this, cx| {
            credentials_provider
                .write_credentials(
                    AMAZON_AWS_URL,
                    "Bearer",
                    &serde_json::to_vec(&credentials)?,
                    cx,
                )
                .await?;
            this.update(cx, |this, cx| {
                this.set_auth(auth);
                this.credentials_from_env = false;
                cx.notify();
            })
        })
    }

    fn is_authenticated(&self) -> bool {
        self.auth.is_some()
    }

    /// Resolve authentication. Settings take priority over UX-provided credentials.
    fn authenticate(&self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
        if self.is_authenticated() {
            return Task::ready(Ok(()));
        }

        // Step 1: Check if settings specify an auth method (enterprise control)
        if let Some(settings) = &self.settings {
            if let Some(method) = &settings.authentication_method {
                let profile_name = settings
                    .profile_name
                    .clone()
                    .unwrap_or_else(|| "default".to_string());

                let auth = match method {
                    BedrockAuthMethod::Automatic => BedrockAuth::Automatic,
                    BedrockAuthMethod::NamedProfile => BedrockAuth::NamedProfile { profile_name },
                    BedrockAuthMethod::SingleSignOn => BedrockAuth::SingleSignOn { profile_name },
                    BedrockAuthMethod::ApiKey => {
                        // ApiKey method means "use static credentials from keychain/env"
                        // Fall through to load them below
                        return self.load_static_credentials(cx);
                    }
                };

                return cx.spawn(async move |this, cx| {
                    this.update(cx, |this, cx| {
                        this.set_auth(Some(auth));
                        this.credentials_from_env = false;
                        cx.notify();
                    })?;
                    Ok(())
                });
            }
        }

        // Step 2: No settings auth method - try to load static credentials
        self.load_static_credentials(cx)
    }

    /// Load static credentials from environment variables or keychain.
    fn load_static_credentials(
        &self,
        cx: &mut Context<Self>,
    ) -> Task<Result<(), AuthenticateError>> {
        let credentials_provider = self.credentials_provider.clone();
        cx.spawn(async move |this, cx| {
            // Try environment variables first
            let (auth, from_env) = if let Some(bearer_token) = &ZED_BEDROCK_BEARER_TOKEN_VAR.value {
                if !bearer_token.is_empty() {
                    (
                        Some(BedrockAuth::ApiKey {
                            api_key: bearer_token.to_string(),
                        }),
                        true,
                    )
                } else {
                    (None, false)
                }
            } else if let Some(access_key_id) = &ZED_BEDROCK_ACCESS_KEY_ID_VAR.value {
                if let Some(secret_access_key) = &ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.value {
                    if !access_key_id.is_empty() && !secret_access_key.is_empty() {
                        let session_token = ZED_BEDROCK_SESSION_TOKEN_VAR
                            .value
                            .as_deref()
                            .filter(|s| !s.is_empty())
                            .map(|s| s.to_string());
                        (
                            Some(BedrockAuth::IamCredentials {
                                access_key_id: access_key_id.to_string(),
                                secret_access_key: secret_access_key.to_string(),
                                session_token,
                            }),
                            true,
                        )
                    } else {
                        (None, false)
                    }
                } else {
                    (None, false)
                }
            } else {
                (None, false)
            };

            // If we got auth from env vars, use it
            if let Some(auth) = auth {
                this.update(cx, |this, cx| {
                    this.set_auth(Some(auth));
                    this.credentials_from_env = from_env;
                    cx.notify();
                })?;
                return Ok(());
            }

            // Try keychain
            let (_, credentials_bytes) =
                language_model::read_credentials(credentials_provider.as_ref(), AMAZON_AWS_URL, cx)
                    .await?
                    .ok_or(AuthenticateError::CredentialsNotFound)?;

            let credentials_str = String::from_utf8(credentials_bytes)
                .with_context(|| format!("invalid {PROVIDER_NAME} credentials"))?;

            let credentials: BedrockCredentials =
                serde_json::from_str(&credentials_str).context("failed to parse credentials")?;

            let auth = credentials
                .into_auth()
                .ok_or(AuthenticateError::CredentialsNotFound)?;

            this.update(cx, |this, cx| {
                this.set_auth(Some(auth));
                this.credentials_from_env = false;
                cx.notify();
            })?;

            Ok(())
        })
    }

    /// Get the resolved region. Checks env var, then settings, then defaults to us-east-1.
    fn get_region(&self) -> String {
        // Priority: env var > settings > default
        if let Some(region) = ZED_BEDROCK_REGION_VAR.value.as_deref() {
            if !region.is_empty() {
                return region.to_string();
            }
        }

        self.settings
            .as_ref()
            .and_then(|s| s.region.clone())
            .unwrap_or_else(|| "us-east-1".to_string())
    }

    fn get_allow_global(&self) -> bool {
        self.settings
            .as_ref()
            .and_then(|s| s.allow_global)
            .unwrap_or(false)
    }

    fn get_guardrail_config(&self) -> (Option<String>, Option<String>) {
        self.settings.as_ref().map_or((None, None), |s| {
            (s.guardrail_identifier.clone(), s.guardrail_version.clone())
        })
    }
}

pub struct BedrockLanguageModelProvider {
    http_client: AwsHttpClient,
    plain_http_client: Arc<dyn HttpClient>,
    state: Entity<State>,
    request_limiters: ModelRateLimiters,
}

/// A model this provider offers, served by either the Converse API or Mantle.
enum BedrockModelConfig {
    Converse(ConverseModel),
    Mantle(MantleModel),
}

impl BedrockLanguageModelProvider {
    pub fn new(
        http_client: Arc<dyn HttpClient>,
        credentials_provider: Arc<dyn CredentialsProvider>,
        cx: &mut App,
    ) -> Self {
        let state = cx.new(|cx| State {
            auth: None,
            settings: Some(AllLanguageModelSettings::get_global(cx).bedrock.clone()),
            credentials_from_env: false,
            credentials_provider,
            expiring_credentials: None,
            auth_generation: 0,
            _subscription: cx.observe_global::<SettingsStore>(|_, cx| {
                cx.notify();
            }),
        });

        Self {
            http_client: AwsHttpClient::new(http_client.clone()),
            plain_http_client: http_client,
            state,
            request_limiters: ModelRateLimiters::default(),
        }
    }

    /// Every model this provider offers, keyed by id: the built-in Converse
    /// models with settings entries added or overriding them, then the same
    /// for Mantle. A Mantle model replaces a Converse model with the same id,
    /// so each id is offered and served exactly once.
    fn bedrock_models(&self, cx: &App) -> IndexMap<String, BedrockModelConfig> {
        let bedrock_settings = &AllLanguageModelSettings::get_global(cx).bedrock;
        let mut models = BTreeMap::default();

        for model in bedrock::ConverseModel::iter() {
            if !matches!(model, bedrock::ConverseModel::Custom { .. }) {
                models.insert(model.id().to_string(), model);
            }
        }

        for model in bedrock_settings.available_models.iter() {
            models.insert(
                model.name.clone(),
                bedrock::ConverseModel::Custom {
                    name: model.name.clone(),
                    display_name: model.display_name.clone(),
                    max_tokens: model.max_tokens,
                    max_output_tokens: model.max_output_tokens,
                    default_temperature: model.default_temperature,
                    cache_configuration: model.cache_configuration.as_ref().map(|config| {
                        bedrock::BedrockModelCacheConfiguration {
                            max_cache_anchors: config.max_cache_anchors,
                            min_total_token: config.min_total_token,
                        }
                    }),
                    supports_tool_use: model.supports_tools,
                    supports_images: model.supports_images,
                    thinking: thinking_from_settings(model.thinking.as_ref()),
                },
            );
        }

        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);
            }
        }

        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),
                },
            );
        }

        let mut all_models = IndexMap::default();
        for (id, model) in models {
            all_models.insert(id, BedrockModelConfig::Converse(model));
        }
        for (id, model) in mantle_models {
            all_models.insert(id, BedrockModelConfig::Mantle(model));
        }
        all_models
    }

    /// Describes the offered model with `id`.
    fn offered_model(&self, id: &str, cx: &App) -> Option<LanguageModel> {
        self.bedrock_models(cx).get(id).map(language_model)
    }

    /// The current configuration of `model`, if this provider still offers it.
    fn config(
        &self,
        model: &LanguageModel,
        cx: &App,
    ) -> Result<BedrockModelConfig, LanguageModelCompletionError> {
        self.bedrock_models(cx)
            .swap_remove(model.id.0.as_ref())
            .ok_or_else(|| unavailable_error(model))
    }
}

fn language_model(config: &BedrockModelConfig) -> LanguageModel {
    match config {
        BedrockModelConfig::Converse(model) => converse_language_model(model),
        BedrockModelConfig::Mantle(model) => mantle_language_model(model),
    }
}

impl LanguageModelProvider for BedrockLanguageModelProvider {
    fn id(&self) -> LanguageModelProviderId {
        PROVIDER_ID
    }

    fn name(&self) -> LanguageModelProviderName {
        PROVIDER_NAME
    }

    fn icon(&self) -> IconOrSvg {
        IconOrSvg::Icon(IconName::AiBedrock)
    }

    fn default_model(&self, cx: &App) -> Option<LanguageModel> {
        self.offered_model(bedrock::ConverseModel::default().id(), cx)
    }

    fn default_fast_model(&self, cx: &App) -> Option<LanguageModel> {
        let region = self.state.read(cx).get_region();
        self.offered_model(
            bedrock::ConverseModel::default_fast(region.as_str()).id(),
            cx,
        )
    }

    fn provided_models(&self, cx: &App) -> Vec<LanguageModel> {
        self.bedrock_models(cx)
            .values()
            .map(language_model)
            .collect()
    }

    fn is_authenticated(&self, cx: &App) -> bool {
        self.state.read(cx).is_authenticated()
    }

    fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
        self.state.update(cx, |state, cx| state.authenticate(cx))
    }

    fn settings_view(&self, _cx: &mut App) -> Option<ProviderSettingsView> {
        let state = self.state.clone();
        Some(ProviderSettingsView::SubPage(
            SubPageProviderSettings::new(move |window, cx| {
                cx.new(|cx| ConfigurationView::new(state.clone(), window, cx))
                    .into()
            })
            .description(InlineDescription::Text(
                "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(),
            )),
        ))
    }
}

impl LanguageModelClient for BedrockLanguageModelProvider {
    fn stream_completion(
        &self,
        model: &LanguageModel,
        request: LanguageModelRequest,
        cx: &AsyncApp,
    ) -> BoxFuture<'static, Result<LanguageModelCompletionStream, LanguageModelCompletionError>>
    {
        let config = match cx.update(|cx| self.config(model, cx)) {
            Ok(config) => config,
            Err(error) => return async move { Err(error) }.boxed(),
        };
        let request_limiter = self.request_limiters.for_model(&model.id);
        match config {
            BedrockModelConfig::Converse(config) => {
                self.stream_converse_completion(&config, &request_limiter, request, cx)
            }
            BedrockModelConfig::Mantle(config) => {
                self.stream_mantle_completion(&config, &request_limiter, request, cx)
            }
        }
    }
}

impl LanguageModelProviderState for BedrockLanguageModelProvider {
    type ObservableEntity = State;

    fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {
        Some(self.state.clone())
    }
}

impl BedrockLanguageModelProvider {
    /// Resolves auth for one request, reusing unexpired cached credentials.
    fn resolve_request_auth(&self, cx: &AsyncApp) -> Task<Result<BedrockRequestAuth>> {
        let http_client = self.http_client.clone();
        self.resolve_request_auth_with(
            cx,
            |name| std::env::var(name).ok(),
            move |auth, region| resolve_request_auth(http_client, auth, region),
        )
    }

    /// [`Self::resolve_request_auth`], reading environment variables with
    /// `environment_variable` and resolving uncached auth with `resolve`.
    fn resolve_request_auth_with<ResolveFuture>(
        &self,
        cx: &AsyncApp,
        environment_variable: impl Fn(&str) -> Option<String>,
        resolve: impl FnOnce(Option<BedrockAuth>, String) -> ResolveFuture,
    ) -> Task<Result<BedrockRequestAuth>>
    where
        ResolveFuture: Future<Output = Result<BedrockRequestAuth>> + Send + 'static,
    {
        let (auth, region, auth_generation, cached_credentials) =
            cx.read_entity(&self.state, |state, _cx| {
                let (auth, region) = (state.auth.clone(), state.get_region());
                let fresh_until = SystemTime::now() + CREDENTIALS_EXPIRY_MARGIN;
                let cached_credentials = state
                    .expiring_credentials
                    .as_ref()
                    .filter(|cached| {
                        cached.auth == auth
                            && cached.region == region
                            && cached
                                .credentials
                                .expiry()
                                .is_some_and(|expiry| expiry > fresh_until)
                    })
                    .map(|cached| cached.credentials.clone());
                (auth, region, state.auth_generation, cached_credentials)
            });
        if !matches!(auth, Some(BedrockAuth::ApiKey { .. }))
            && let Some(api_key) = environment_bearer_token(environment_variable)
        {
            return Task::ready(Ok(BedrockRequestAuth::ApiKey { api_key }));
        }
        if let Some(credentials) = cached_credentials {
            return Task::ready(Ok(BedrockRequestAuth::SigV4 { credentials }));
        }

        let resolve_task = Tokio::spawn_result(cx, resolve(auth.clone(), region.clone()));
        let timeout = cx.background_executor().timer(CREDENTIALS_LOAD_TIMEOUT);
        let state = self.state.clone();
        cx.spawn(async move |cx| {
            // Dropping `resolve_task` on timeout cancels the Tokio task.
            let request_auth = futures::select_biased! {
                request_auth = resolve_task.fuse() => request_auth?,
                _ = timeout.fuse() => anyhow::bail!(
                    "timed out after {CREDENTIALS_LOAD_TIMEOUT:?} resolving AWS credentials"
                ),
            };
            if let BedrockRequestAuth::SigV4 { credentials } = &request_auth
                && credentials.expiry().is_some()
            {
                let credentials = credentials.clone();
                state.update(cx, |state, _| {
                    if state.auth_generation == auth_generation {
                        state.expiring_credentials = Some(ExpiringCredentials {
                            auth,
                            region,
                            credentials,
                        });
                    }
                });
            }
            Ok(request_auth)
        })
    }

    fn stream_bedrock_request(
        &self,
        request: bedrock::Request,
        cx: &AsyncApp,
    ) -> BoxFuture<
        'static,
        Result<BoxStream<'static, Result<BedrockStreamingResponse, anyhow::Error>>, BedrockError>,
    > {
        let http_client = self.http_client.clone();
        let auth_task = self.resolve_request_auth(cx);
        let (profile_name, endpoint, region, extra_headers) =
            self.state.read_with(cx, |state, cx| {
                (
                    aws_profile_name(&state.auth),
                    state.settings.as_ref().and_then(|s| s.endpoint.clone()),
                    state.get_region(),
                    AllLanguageModelSettings::get_global(cx)
                        .bedrock
                        .custom_headers
                        .clone(),
                )
            });

        let task = Tokio::spawn(cx, async move {
            let request_auth = auth_task.await.map_err(BedrockError::Other)?;
            let client =
                build_converse_client(http_client, request_auth, profile_name, endpoint, region)
                    .await;
            bedrock::stream_completion(client, request, extra_headers).await
        });
        async move { task.await.map_err(|e| BedrockError::Other(e.into()))? }.boxed()
    }
}

/// Builds a Converse client for one request from already-resolved auth. The
/// profile still applies, since it can configure more than credentials.
async fn build_converse_client(
    http_client: AwsHttpClient,
    request_auth: BedrockRequestAuth,
    profile_name: Option<String>,
    endpoint: Option<String>,
    region: String,
) -> BedrockClient {
    let mut config_builder = aws_config::defaults(BehaviorVersion::latest())
        .stalled_stream_protection(StalledStreamProtectionConfig::disabled())
        .http_client(http_client)
        .region(Region::new(region))
        .timeout_config(TimeoutConfig::disabled());

    if let Some(profile_name) = profile_name {
        config_builder = config_builder.profile_name(profile_name);
    }
    if let Some(endpoint_url) = endpoint
        && !endpoint_url.is_empty()
    {
        config_builder = config_builder.endpoint_url(endpoint_url);
    }

    config_builder = match request_auth {
        BedrockRequestAuth::SigV4 { credentials } => {
            config_builder.credentials_provider(credentials)
        }
        BedrockRequestAuth::ApiKey { api_key } => config_builder
            .auth_scheme_preference(["httpBearerAuth".into()]) // https://github.com/smithy-lang/smithy-rs/pull/4241
            .token_provider(Token::new(api_key, None)),
    };

    BedrockClient::new(&config_builder.load().await)
}

fn converse_language_model(model: &ConverseModel) -> LanguageModel {
    let is_gpt_6_astra = matches!(model, ConverseModel::Gpt6Astra);
    let reasoning_model = converse_reasoning_model(model.request_id());
    LanguageModel {
        supports_tools: model.supports_tool_use(),
        supports_images: model.supports_images(),
        supports_thinking: model.supports_thinking(),
        // These models always reason, so only offer effort levels.
        supports_disabling_thinking: reasoning_model.is_none(),
        refusal_fallback_model_id: model
            .id()
            .starts_with(anthropic::FABLE_MODEL_ID_PREFIX)
            .then_some(anthropic::FABLE_FALLBACK_MODEL_ID),
        supported_effort_levels: if model.supports_adaptive_thinking() || is_gpt_6_astra {
            vec![
                language_model::LanguageModelEffortLevel {
                    name: "Low".into(),
                    value: "low".into(),
                    is_default: false,
                    supports_disabling_thinking: None,
                },
                language_model::LanguageModelEffortLevel {
                    name: "Medium".into(),
                    value: "medium".into(),
                    is_default: is_gpt_6_astra,
                    supports_disabling_thinking: None,
                },
                language_model::LanguageModelEffortLevel {
                    name: "High".into(),
                    value: "high".into(),
                    is_default: !is_gpt_6_astra,
                    supports_disabling_thinking: None,
                },
                language_model::LanguageModelEffortLevel {
                    name: "XHigh".into(),
                    value: "xhigh".into(),
                    is_default: false,
                    supports_disabling_thinking: None,
                },
                language_model::LanguageModelEffortLevel {
                    name: "Max".into(),
                    value: "max".into(),
                    is_default: false,
                    supports_disabling_thinking: None,
                },
            ]
            .into_iter()
            .filter(|effort_level| {
                effort_level.value != "xhigh"
                    || model.supports_xhigh_adaptive_thinking()
                    || is_gpt_6_astra
            })
            .collect()
        } else {
            Arc::default()
        },
        // Add support for None - we'll filter tool calls at response
        tool_choice_support: LanguageModelToolChoiceSupport {
            auto: model.supports_tool_use(),
            any: model.supports_tool_use()
                && anthropic::supports_forced_tool_use(
                    reasoning_model.as_ref().unwrap_or(model).id(),
                ),
            none: model.supports_tool_use(),
        },
        supports_streaming_tools: true,
        max_output_tokens: Some(model.max_output_tokens()),
        ..LanguageModel::new(
            LanguageModelId::from(model.id().to_string()),
            LanguageModelName::from(model.display_name().to_string()),
            PROVIDER_ID,
            PROVIDER_NAME,
            format!("bedrock/{}", model.id()),
            model.max_token_count(),
        )
    }
}

impl BedrockLanguageModelProvider {
    fn stream_converse_completion(
        &self,
        config: &ConverseModel,
        request_limiter: &RateLimiter,
        request: LanguageModelRequest,
        cx: &AsyncApp,
    ) -> BoxFuture<'static, Result<LanguageModelCompletionStream, LanguageModelCompletionError>>
    {
        if request.contains_custom_tool_input() {
            return async move {
                Err(anyhow::anyhow!("Bedrock does not support custom tools").into())
            }
            .boxed();
        }

        let (region, allow_global, guardrail_identifier, guardrail_version) =
            cx.read_entity(&self.state, |state, _cx| {
                let (gid, gv) = state.get_guardrail_config();
                (state.get_region(), state.get_allow_global(), gid, gv)
            });

        let model_id = match config.cross_region_inference_id(&region, allow_global) {
            Ok(s) => s,
            Err(e) => {
                return async move { Err(e.into()) }.boxed();
            }
        };

        let deny_tool_calls = request.tool_choice == Some(LanguageModelToolChoice::None);

        let request = match into_bedrock(
            request,
            model_id.clone(),
            config.default_temperature(),
            config.max_output_tokens(),
            config.thinking_mode(),
            config.supports_caching(),
            config.supports_tool_use(),
            guardrail_identifier,
            guardrail_version,
        ) {
            Ok(request) => request,
            Err(err) => return futures::future::ready(Err(err.into())).boxed(),
        };

        let request = self.stream_bedrock_request(request, cx);
        let model = config.clone();
        let executor = cx.background_executor().clone();
        let future = request_limiter.stream(async move {
            let response = request.await.map_err(|err| match err {
                BedrockError::Validation(ref msg) => {
                    if msg.contains("model identifier is invalid") {
                        LanguageModelCompletionError::from_provider_response(
                            PROVIDER_NAME,
                            None,
                            Some("ValidationException".to_string()),
                            format!("Bedrock rejected model ID `{model_id}` in {region}: {msg}"),
                            None,
                            ProviderErrorCategory::InvalidRequest,
                        )
                    } else {
                        LanguageModelCompletionError::from_provider_response(
                            PROVIDER_NAME,
                            None,
                            Some("ValidationException".to_string()),
                            msg.clone(),
                            None,
                            ProviderErrorCategory::InvalidRequest,
                        )
                    }
                }
                BedrockError::RateLimited => LanguageModelCompletionError::from_provider_response(
                    PROVIDER_NAME,
                    None,
                    Some("ThrottlingException".to_string()),
                    "Bedrock request was throttled".to_string(),
                    None,
                    ProviderErrorCategory::RateLimit,
                ),
                BedrockError::ServiceUnavailable => {
                    LanguageModelCompletionError::from_provider_response(
                        PROVIDER_NAME,
                        None,
                        Some("ServiceUnavailableException".to_string()),
                        "Bedrock service is temporarily unavailable".to_string(),
                        None,
                        ProviderErrorCategory::Overloaded,
                    )
                }
                BedrockError::AccessDenied(msg) => {
                    LanguageModelCompletionError::from_provider_response(
                        PROVIDER_NAME,
                        None,
                        Some("AccessDeniedException".to_string()),
                        msg,
                        None,
                        ProviderErrorCategory::Permission,
                    )
                }
                BedrockError::InternalServer(msg) => {
                    LanguageModelCompletionError::from_provider_response(
                        PROVIDER_NAME,
                        None,
                        Some("InternalServerException".to_string()),
                        msg,
                        None,
                        ProviderErrorCategory::InternalServer,
                    )
                }
                other => LanguageModelCompletionError::Other(anyhow!(other)),
            })?;
            let events = language_model::stream_in_background(
                map_to_language_model_completion_events(response, model).boxed(),
                executor,
            );

            if deny_tool_calls {
                Ok(deny_tool_use_events(events).boxed())
            } else {
                Ok(events.boxed())
            }
        });

        async move { Ok(future.await?.boxed()) }.boxed()
    }
}

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,
            supports_disabling_thinking: None,
        })
        .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::from_provider_response(
            PROVIDER_NAME,
            Some(http_client::http::StatusCode::FORBIDDEN),
            None,
            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()
            ),
            None,
            ProviderErrorCategory::Permission,
        );
    }
    error.into()
}

/// The AWS profile named by profile or SSO auth, if any.
fn aws_profile_name(auth: &Option<BedrockAuth>) -> Option<String> {
    match auth {
        Some(BedrockAuth::NamedProfile { profile_name })
        | Some(BedrockAuth::SingleSignOn { profile_name }) => {
            Some(profile_name.clone()).filter(|name| !name.is_empty())
        }
        _ => None,
    }
}

/// Resolves provider settings into concrete request auth. A configured Bedrock
/// API key is sent as bearer auth; every other method resolves AWS
/// credentials to sign the request with SigV4.
async fn resolve_request_auth(
    http_client: AwsHttpClient,
    auth: Option<BedrockAuth>,
    region: String,
) -> Result<BedrockRequestAuth> {
    let profile_name = match auth {
        Some(BedrockAuth::ApiKey { api_key }) => return Ok(BedrockRequestAuth::ApiKey { api_key }),
        Some(BedrockAuth::IamCredentials {
            access_key_id,
            secret_access_key,
            session_token,
        }) => {
            return Ok(BedrockRequestAuth::SigV4 {
                credentials: Credentials::new(
                    access_key_id,
                    secret_access_key,
                    session_token,
                    None,
                    "zed-bedrock-provider",
                ),
            });
        }
        _ => aws_profile_name(&auth),
    };

    let mut config_builder = aws_config::defaults(BehaviorVersion::latest())
        .http_client(http_client)
        .region(Region::new(region));
    if let Some(profile_name) = profile_name {
        config_builder = config_builder.profile_name(profile_name);
    }
    let credentials = config_builder
        .load()
        .await
        .credentials_provider()
        .context("no AWS credentials provider is configured")
        .context("resolving AWS credentials for Bedrock")?
        .provide_credentials()
        .await
        .context("failed to resolve AWS credentials")?;
    Ok(BedrockRequestAuth::SigV4 { credentials })
}

fn parse_mantle_chat_stream_line(line: &str) -> Result<ResponseStreamEvent> {
    match serde_json::from_str::<ResponseStreamResult>(line) {
        Ok(ResponseStreamResult::Ok(response)) => Ok(response),
        Ok(ResponseStreamResult::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: &BedrockRequestAuth,
    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: Box::new(response.headers().clone()),
        })
    }
}

fn strip_unsupported_mantle_response_fields(request: &mut OpenAiResponseRequest) {
    request.context_management = None;
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum MantleMessageSnapshotKind {
    Undetermined,
    Cumulative,
    Independent,
}

struct MantleMessageSnapshot {
    item_id: String,
    text: String,
    emitted_text_length: usize,
    kind: MantleMessageSnapshotKind,
    phase: Option<String>,
    output_index: usize,
    content_index: Option<usize>,
}

/// The most recently completed message item, used to detect Mantle's cumulative
/// snapshot replays.
#[derive(Clone)]
struct MantlePreviousMessage {
    text: String,
    phase: Option<String>,
}

/// Adapts Mantle's cumulative Responses message snapshots to incremental events.
///
/// Mantle can emit a new message item containing all text produced so far, then
/// replay the corresponding output deltas. The shared OpenAI mapper assumes each
/// delta is new text, so forwarding those events directly duplicates the reply.
///
/// Only adjacent, same-phase, strict-prefix extensions are collapsed. Equal,
/// shrinking, divergent, or different-phase messages stay visible. Any non-message
/// output item (reasoning, tool call, etc.) is a hard boundary: it is forwarded
/// unchanged and clears the snapshot used for collapsing, so a message after a
/// tool call is never merged with the one before it.
struct MantleResponseEventMapper {
    open_ai_mapper: OpenAiResponseEventMapper,
    current_message: Option<MantleMessageSnapshot>,
    previous_message: Option<MantlePreviousMessage>,
    pending_message_events: Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
}

impl MantleResponseEventMapper {
    fn new() -> Self {
        Self {
            open_ai_mapper: OpenAiResponseEventMapper::new(PROVIDER_ID),
            current_message: None,
            previous_message: None,
            pending_message_events: Vec::new(),
        }
    }

    fn map_stream(
        mut self,
        events: BoxStream<'static, Result<OpenAiResponseStreamEvent>>,
    ) -> LanguageModelCompletionStream {
        events
            .flat_map(move |event| {
                futures::stream::iter(match event {
                    Ok(event) => self.map_event(event),
                    Err(error) => {
                        let mut events = self.finish_current_message();
                        events.push(Err(LanguageModelCompletionError::from(error)));
                        events
                    }
                })
            })
            .boxed()
    }

    fn map_event(
        &mut self,
        event: OpenAiResponseStreamEvent,
    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
        match event {
            OpenAiResponseStreamEvent::OutputItemAdded {
                output_index,
                sequence_number,
                item,
            } => match &item {
                ResponseOutputItem::Message(message) => {
                    let mut events = self.finish_current_message();
                    let item_id = message.id.clone();
                    let phase = message.phase.clone();
                    if let Some(item_id) = item_id {
                        self.current_message = Some(MantleMessageSnapshot {
                            item_id,
                            text: String::new(),
                            emitted_text_length: 0,
                            kind: MantleMessageSnapshotKind::Undetermined,
                            phase,
                            output_index,
                            content_index: None,
                        });

                        self.map_message_added(OpenAiResponseStreamEvent::OutputItemAdded {
                            output_index,
                            sequence_number,
                            item,
                        });
                    } else {
                        self.flush_pending_message(&mut events, false);
                        events.extend(self.open_ai_mapper.map_event(
                            OpenAiResponseStreamEvent::OutputItemAdded {
                                output_index,
                                sequence_number,
                                item,
                            },
                        ));
                    }
                    events
                }
                _ => {
                    let mut events = self.finish_current_message();
                    self.previous_message = None;
                    events.extend(self.open_ai_mapper.map_event(
                        OpenAiResponseStreamEvent::OutputItemAdded {
                            output_index,
                            sequence_number,
                            item,
                        },
                    ));
                    events
                }
            },
            OpenAiResponseStreamEvent::OutputTextDelta {
                item_id,
                output_index,
                content_index,
                delta,
            } => self.map_text_delta(item_id, output_index, content_index, delta),
            OpenAiResponseStreamEvent::OutputTextDone {
                item_id,
                output_index,
                content_index,
                text,
            } => {
                let suffix = self
                    .current_message
                    .as_ref()
                    .filter(|message| message.item_id == item_id)
                    .and_then(|message| text.strip_prefix(&message.text))
                    .map(str::to_string);
                if let Some(suffix) = suffix {
                    if suffix.is_empty() {
                        return Vec::new();
                    }
                    return self.map_text_delta(item_id, output_index, content_index, suffix);
                }

                let mut events = self.finish_current_message();
                events.extend(self.open_ai_mapper.map_event(
                    OpenAiResponseStreamEvent::OutputTextDone {
                        item_id,
                        output_index,
                        content_index,
                        text,
                    },
                ));
                events
            }
            OpenAiResponseStreamEvent::ContentPartAdded { ref item_id, .. }
            | OpenAiResponseStreamEvent::ContentPartDone { ref item_id, .. }
            | OpenAiResponseStreamEvent::RefusalDelta { ref item_id, .. }
            | OpenAiResponseStreamEvent::RefusalDone { ref item_id, .. }
                if self
                    .current_message
                    .as_ref()
                    .is_some_and(|message| &message.item_id == item_id) =>
            {
                self.open_ai_mapper.map_event(event)
            }
            OpenAiResponseStreamEvent::OutputItemDone {
                output_index,
                sequence_number,
                item,
            } => {
                if let ResponseOutputItem::Message(message) = &item
                    && let Some(item_id) = message.id.as_ref()
                    && let Some(current_message) = self.current_message.as_mut()
                    && &current_message.item_id == item_id
                {
                    current_message.phase = message.phase.clone();
                }

                let is_non_message = !matches!(item, ResponseOutputItem::Message(_));
                let was_merged = matches!(
                    self.current_message.as_ref(),
                    Some(current_message)
                        if current_message.kind == MantleMessageSnapshotKind::Cumulative
                );
                let mut events = self.finish_current_message();
                if is_non_message {
                    self.previous_message = None;
                }
                let done_events =
                    self.open_ai_mapper
                        .map_event(OpenAiResponseStreamEvent::OutputItemDone {
                            output_index,
                            sequence_number,
                            item,
                        });
                if was_merged {
                    // The message was merged into the previous one, so the phase/
                    // reasoning metadata this `OutputItemDone` would otherwise emit
                    // again is already reflected by the metadata emitted earlier.
                    events.extend(done_events.into_iter().filter(|event| {
                        !matches!(event, Ok(LanguageModelCompletionEvent::ReasoningDetails(_)))
                    }));
                } else {
                    events.extend(done_events);
                }
                events
            }
            event => {
                let mut events = self.finish_current_message();
                events.extend(self.open_ai_mapper.map_event(event));
                events
            }
        }
    }

    fn map_message_added(&mut self, event: OpenAiResponseStreamEvent) {
        debug_assert!(
            self.pending_message_events.is_empty(),
            "pending message events must be flushed before a new message is added"
        );
        self.pending_message_events = self.open_ai_mapper.map_event(event);
    }

    fn map_text_delta(
        &mut self,
        item_id: String,
        output_index: usize,
        content_index: Option<usize>,
        delta: String,
    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
        if !self
            .current_message
            .as_ref()
            .is_some_and(|current_message| current_message.item_id == item_id)
        {
            let mut events = self.finish_current_message();
            events.extend(self.open_ai_mapper.map_event(
                OpenAiResponseStreamEvent::OutputTextDelta {
                    item_id,
                    output_index,
                    content_index,
                    delta,
                },
            ));
            return events;
        }

        let Some(current_message) = self.current_message.as_mut() else {
            return Vec::new();
        };
        current_message.text.push_str(&delta);
        current_message.output_index = output_index;
        current_message.content_index = content_index;
        let kind = current_message.kind;

        match kind {
            MantleMessageSnapshotKind::Undetermined => {
                let snapshot = current_message.text.clone();
                let phase = current_message.phase.clone();
                let previous = self.previous_message.clone();

                if let Some(previous) = previous
                    && previous.phase == phase
                {
                    // Strict same-phase extension: previous text is a proper prefix of
                    // the new snapshot. Collapse the replayed prefix and emit only the
                    // suffix.
                    if snapshot.starts_with(&previous.text) && snapshot.len() > previous.text.len()
                    {
                        if let Some(current_message) = self.current_message.as_mut() {
                            current_message.kind = MantleMessageSnapshotKind::Cumulative;
                            current_message.emitted_text_length = previous.text.len();
                        }
                        let mut events = Vec::new();
                        self.flush_pending_message(&mut events, true);
                        events.extend(self.map_snapshot_suffix(output_index, content_index));
                        return events;
                    }

                    // The snapshot is still a prefix of (or equal to) the previous
                    // message. A genuine cumulative replay keeps growing past the
                    // previous text, so defer the decision and withhold emission
                    // until it either exceeds the previous text or diverges.
                    if previous.text.starts_with(&snapshot) {
                        return Vec::new();
                    }
                }

                // Diverged from the previous message, had a different phase, or there
                // was no previous message: this is an independent message.
                if let Some(current_message) = self.current_message.as_mut() {
                    current_message.kind = MantleMessageSnapshotKind::Independent;
                }
                let mut events = Vec::new();
                self.flush_pending_message(&mut events, false);
                events.extend(self.map_text_event(item_id, output_index, content_index, snapshot));
                events
            }
            MantleMessageSnapshotKind::Cumulative => {
                self.map_snapshot_suffix(output_index, content_index)
            }
            MantleMessageSnapshotKind::Independent => {
                self.map_text_event(item_id, output_index, content_index, delta)
            }
        }
    }

    fn map_snapshot_suffix(
        &mut self,
        output_index: usize,
        content_index: Option<usize>,
    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
        let (item_id, suffix) = {
            let Some(current_message) = self.current_message.as_mut() else {
                return Vec::new();
            };

            if current_message.text.len() <= current_message.emitted_text_length {
                return Vec::new();
            }

            let suffix = current_message.text[current_message.emitted_text_length..].to_string();
            current_message.emitted_text_length = current_message.text.len();
            (current_message.item_id.clone(), suffix)
        };

        self.map_text_event(item_id, output_index, content_index, suffix)
    }

    fn map_text_event(
        &mut self,
        item_id: String,
        output_index: usize,
        content_index: Option<usize>,
        delta: String,
    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
        if delta.is_empty() {
            return Vec::new();
        }

        self.open_ai_mapper
            .map_event(OpenAiResponseStreamEvent::OutputTextDelta {
                item_id,
                output_index,
                content_index,
                delta,
            })
    }

    fn finish_current_message(
        &mut self,
    ) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
        let mut events = Vec::new();
        self.finish_current_message_into(&mut events);
        events
    }

    fn finish_current_message_into(
        &mut self,
        events: &mut Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
    ) {
        let Some(current_message) = self.current_message.take() else {
            self.flush_pending_message(events, false);
            return;
        };

        match current_message.kind {
            MantleMessageSnapshotKind::Cumulative => {
                self.flush_pending_message(events, true);
            }
            MantleMessageSnapshotKind::Independent => {
                self.flush_pending_message(events, false);
            }
            MantleMessageSnapshotKind::Undetermined => {
                // The message never exceeded or diverged from the previous one, so
                // it could not be confirmed as a cumulative replay. Treat it as an
                // independent message: emit the withheld StartMessage and any text
                // accumulated while deferring the decision.
                self.flush_pending_message(events, false);
                if !current_message.text.is_empty() {
                    events.extend(self.map_text_event(
                        current_message.item_id.clone(),
                        current_message.output_index,
                        current_message.content_index,
                        current_message.text.clone(),
                    ));
                }
            }
        }

        if !current_message.text.is_empty() {
            self.previous_message = Some(MantlePreviousMessage {
                text: current_message.text,
                phase: current_message.phase,
            });
        }
    }

    fn flush_pending_message(
        &mut self,
        events: &mut Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
        suppress_start_message: bool,
    ) {
        for event in self.pending_message_events.drain(..) {
            // When merging into the previous message, the phase/reasoning metadata
            // can't have changed since it was last emitted (a merge only happens for
            // adjacent, same-phase messages with no reasoning item in between), so
            // suppress both the StartMessage and the now-redundant ReasoningDetails.
            if suppress_start_message
                && matches!(
                    event,
                    Ok(LanguageModelCompletionEvent::StartMessage { .. })
                        | Ok(LanguageModelCompletionEvent::ReasoningDetails(_))
                )
            {
                continue;
            }
            events.push(event);
        }
    }
}

impl BedrockLanguageModelProvider {
    fn stream_mantle_request<Request, Event>(
        &self,
        config: &MantleModel,
        request_limiter: &RateLimiter,
        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.plain_http_client.clone();
        let model = config.clone();
        let region = cx.read_entity(&self.state, |state, _cx| 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 = self.resolve_request_auth(cx);

        let future = 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_chat_completion(
        &self,
        config: &MantleModel,
        request_limiter: &RateLimiter,
        request: open_ai::Request,
        cx: &AsyncApp,
    ) -> BoxFuture<
        'static,
        Result<BoxStream<'static, Result<ResponseStreamEvent>>, LanguageModelCompletionError>,
    > {
        self.stream_mantle_request(
            config,
            request_limiter,
            request,
            cx,
            "chat/completions",
            parse_mantle_chat_stream_line,
        )
    }

    fn stream_response(
        &self,
        config: &MantleModel,
        request_limiter: &RateLimiter,
        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(
            config,
            request_limiter,
            request,
            cx,
            "responses",
            parse_mantle_response_stream_line,
        )
    }
}

fn mantle_language_model(model: &MantleModel) -> LanguageModel {
    LanguageModel {
        supports_tools: model.supports_tools(),
        supports_images: model.supports_images(),
        tool_choice_support: LanguageModelToolChoiceSupport {
            auto: model.supports_tools(),
            any: model.supports_tools(),
            none: true,
        },
        supports_streaming_tools: true,
        supports_thinking: model.supports_thinking(),
        supported_effort_levels: mantle_supported_effort_levels(model).into(),
        supports_split_token_display: true,
        max_output_tokens: Some(model.max_output_tokens()),
        ..LanguageModel::new(
            LanguageModelId::from(model.id().to_string()),
            LanguageModelName::from(model.display_name().to_string()),
            PROVIDER_ID,
            PROVIDER_NAME,
            format!("bedrock-mantle/{}", model.id()),
            model.max_token_count(),
        )
    }
}

impl BedrockLanguageModelProvider {
    fn stream_mantle_completion(
        &self,
        config: &MantleModel,
        request_limiter: &RateLimiter,
        request: LanguageModelRequest,
        cx: &AsyncApp,
    ) -> BoxFuture<'static, Result<LanguageModelCompletionStream, LanguageModelCompletionError>>
    {
        let region = cx.read_entity(&self.state, |state, _cx| state.get_region());

        if !MANTLE_SUPPORTED_REGIONS.contains(&region.as_str()) {
            let display_name = config.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 = config.request_id().to_string();
        let max_output_tokens = Some(config.max_output_tokens());

        match config.protocol() {
            MantleProtocol::Responses => {
                let request = match into_open_ai_response(
                    request,
                    &model_id,
                    config.supports_tools(),
                    false,
                    max_output_tokens,
                    mantle_default_reasoning_effort(config),
                    config.supports_thinking(),
                    &PROVIDER_ID,
                ) {
                    Ok(request) => request,
                    Err(error) => return async move { Err(error.into()) }.boxed(),
                };
                let completions = self.stream_response(config, request_limiter, request, cx);
                let executor = cx.background_executor().clone();
                async move {
                    let mapper = MantleResponseEventMapper::new();
                    Ok(language_model::stream_in_background(
                        mapper.map_stream(completions.await?).boxed(),
                        executor,
                    ))
                }
                .boxed()
            }
            MantleProtocol::ChatCompletions => {
                let reasoning_effort = mantle_selected_reasoning_effort(&request, config);
                let request = match into_open_ai(
                    request,
                    &model_id,
                    config.supports_tools(),
                    false,
                    max_output_tokens,
                    ChatCompletionMaxTokensParameter::MaxCompletionTokens,
                    reasoning_effort,
                    false,
                ) {
                    Ok(request) => request,
                    Err(error) => return async move { Err(error.into()) }.boxed(),
                };
                let completions = self.stream_chat_completion(config, request_limiter, request, cx);
                let executor = cx.background_executor().clone();
                async move {
                    let mapper = ChatCompletionEventMapper::new();
                    Ok(language_model::stream_in_background(
                        mapper.map_stream(completions.await?).boxed(),
                        executor,
                    ))
                }
                .boxed()
            }
        }
    }
}

fn deny_tool_use_events(
    events: impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
    events.map(|event| {
        match event {
            Ok(LanguageModelCompletionEvent::ToolUse(tool_use)) => {
                // Convert tool use to an error message if model decided to call it
                Ok(LanguageModelCompletionEvent::Text(format!(
                    "\n\n[Error: Tool calls are disabled in this context. Attempted to call '{}']",
                    tool_use.name
                )))
            }
            other => other,
        }
    })
}

/// Matches by Bedrock model ID, so custom entries such as
/// `us.anthropic.claude-fable-5-1` get the same handling as the built-in model.
fn converse_reasoning_model(model_id: &str) -> Option<ConverseModel> {
    [
        ConverseModel::Gpt6Astra,
        ConverseModel::ClaudeFable5_1,
        ConverseModel::ClaudeOpus5_5,
    ]
    .into_iter()
    .find(|model| model_id.ends_with(model.request_id()))
}

fn prepare_bedrock_content(
    content: Vec<BedrockInnerContent>,
    tool_result_images_as_siblings: bool,
) -> Vec<BedrockInnerContent> {
    let mut prepared = Vec::with_capacity(content.len());
    let mut images = Vec::new();
    for block in content {
        match block {
            BedrockInnerContent::ToolResult(mut result) if tool_result_images_as_siblings => {
                // OpenAI expects parallel tool results before their sibling images.
                // <https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ToolResultContentBlock.html>
                let mut has_images = false;
                for content in std::mem::take(&mut result.content) {
                    match content {
                        BedrockToolResultContentBlock::Image(image) => {
                            has_images = true;
                            images.push(BedrockInnerContent::Image(image))
                        }
                        other => result.content.push(other),
                    }
                }
                if has_images && result.content.is_empty() {
                    result.content.push(BedrockToolResultContentBlock::Text(
                        "See the attached image output.".into(),
                    ));
                }
                prepared.push(BedrockInnerContent::ToolResult(result));
            }
            other => {
                prepared.append(&mut images);
                prepared.push(other);
            }
        }
    }
    prepared.append(&mut images);
    prepared
}

pub fn into_bedrock(
    request: LanguageModelRequest,
    model: String,
    default_temperature: Option<f32>,
    max_output_tokens: u64,
    thinking_mode: BedrockModelMode,
    supports_caching: bool,
    supports_tool_use: bool,
    guardrail_identifier: Option<String>,
    guardrail_version: Option<String>,
) -> Result<bedrock::Request> {
    let max_output_tokens = request
        .max_output_tokens
        .map_or(max_output_tokens, |limit| limit.min(max_output_tokens));
    if request.contains_custom_tool_input() {
        anyhow::bail!("Bedrock does not support custom tools");
    }

    let reasoning_model = converse_reasoning_model(&model);
    let always_adaptive = matches!(
        reasoning_model,
        Some(ConverseModel::ClaudeFable5_1 | ConverseModel::ClaudeOpus5_5)
    );
    let is_gpt_6_astra = reasoning_model == Some(ConverseModel::Gpt6Astra);
    if always_adaptive && request.tool_choice == Some(LanguageModelToolChoice::Any) {
        anyhow::bail!("{model} does not support forced tool use");
    }

    let mut new_messages: Vec<BedrockMessage> = Vec::new();
    let mut system_message = String::new();

    // Track whether messages contain tool content - Bedrock requires toolConfig
    // when tool blocks are present, so we may need to add a dummy tool
    let mut messages_contain_tool_content = false;

    for message in request.messages {
        if message.contents_empty() {
            continue;
        }

        let reasoning_source = message
            .reasoning_details
            .as_ref()
            .and_then(|details| details.get("bedrock_model"))
            .and_then(Value::as_str);
        let replay_reasoning = match reasoning_source {
            Some(source) => reasoning_model
                .as_ref()
                .is_some_and(|model| model.request_id() == source),
            None => reasoning_model.is_none(),
        };

        match message.role {
            Role::User | Role::Assistant => {
                let mut bedrock_message_content: Vec<BedrockInnerContent> = message
                    .content
                    .into_iter()
                    .filter_map(|content| match content {
                        MessageContent::Text(text) => {
                            if !text.is_empty() {
                                Some(BedrockInnerContent::Text(text))
                            } else {
                                None
                            }
                        }
                        MessageContent::Compaction(_) => None,
                        MessageContent::Thinking { text, signature } => {
                            if !replay_reasoning {
                                return None;
                            }
                            if model.contains(ConverseModel::DeepSeekR1.request_id()) {
                                // DeepSeekR1 doesn't support thinking blocks
                                // And the AWS API demands that you strip them
                                return None;
                            }
                            if signature.is_none() {
                                // Thinking blocks without a signature are invalid
                                // (e.g. from cancellation mid-think) and must be
                                // stripped to avoid API errors.
                                return None;
                            }
                            let thinking = BedrockThinkingTextBlock::builder()
                                .text(text)
                                .set_signature(signature)
                                .build()
                                .context("failed to build reasoning block")
                                .log_err()?;

                            Some(BedrockInnerContent::ReasoningContent(
                                BedrockThinkingBlock::ReasoningText(thinking),
                            ))
                        }
                        MessageContent::RedactedThinking(blob) => {
                            if !replay_reasoning {
                                return None;
                            }
                            if model.contains(ConverseModel::DeepSeekR1.request_id()) {
                                // DeepSeekR1 doesn't support thinking blocks
                                // And the AWS API demands that you strip them
                                return None;
                            }
                            use base64::Engine;

                            let bytes = base64::engine::general_purpose::STANDARD
                                .decode(blob.as_bytes())
                                .context("Invalid base64 in Bedrock reasoning history")
                                .log_err()?;
                            let redacted =
                                BedrockThinkingBlock::RedactedContent(BedrockBlob::new(bytes));

                            Some(BedrockInnerContent::ReasoningContent(redacted))
                        }
                        MessageContent::ToolUse(tool_use) => {
                            messages_contain_tool_content = true;
                            let input =
                                if let language_model::LanguageModelToolUseInput::Json(input) =
                                    &tool_use.input
                                {
                                    if input.is_null() {
                                        // Bedrock API requires valid JsonValue, not null, for tool use input
                                        value_to_aws_document(&serde_json::json!({}))
                                    } else {
                                        value_to_aws_document(input)
                                    }
                                } else {
                                    value_to_aws_document(&serde_json::json!({}))
                                };
                            BedrockToolUseBlock::builder()
                                .name(tool_use.name.to_string())
                                .tool_use_id(tool_use.id.to_string())
                                .input(input)
                                .build()
                                .context("failed to build Bedrock tool use block")
                                .log_err()
                                .map(BedrockInnerContent::ToolUse)
                        }
                        MessageContent::ToolResult(tool_result) => {
                            messages_contain_tool_content = true;
                            let mut builder = BedrockToolResultBlock::builder()
                                .tool_use_id(tool_result.tool_use_id.to_string());
                            for part in tool_result.content {
                                let block = match part {
                                    LanguageModelToolResultContent::Text(text) => {
                                        BedrockToolResultContentBlock::Text(text.to_string())
                                    }
                                    LanguageModelToolResultContent::Image(image) => {
                                        use base64::Engine;

                                        match base64::engine::general_purpose::STANDARD
                                            .decode(image.source.as_bytes())
                                        {
                                            Ok(image_bytes) => {
                                                match BedrockImageBlock::builder()
                                                    .format(BedrockImageFormat::Png)
                                                    .source(BedrockImageSource::Bytes(
                                                        BedrockBlob::new(image_bytes),
                                                    ))
                                                    .build()
                                                {
                                                    Ok(image_block) => {
                                                        BedrockToolResultContentBlock::Image(
                                                            image_block,
                                                        )
                                                    }
                                                    Err(err) => {
                                                        BedrockToolResultContentBlock::Text(
                                                            format!(
                                                                "[Failed to build image block: {}]",
                                                                err
                                                            ),
                                                        )
                                                    }
                                                }
                                            }
                                            Err(err) => {
                                                BedrockToolResultContentBlock::Text(format!(
                                                    "[Failed to decode tool result image: {}]",
                                                    err
                                                ))
                                            }
                                        }
                                    }
                                };
                                builder = builder.content(block);
                            }
                            builder
                                .status({
                                    if tool_result.is_error {
                                        BedrockToolResultStatus::Error
                                    } else {
                                        BedrockToolResultStatus::Success
                                    }
                                })
                                .build()
                                .context("failed to build Bedrock tool result block")
                                .log_err()
                                .map(BedrockInnerContent::ToolResult)
                        }
                        MessageContent::Image(image) => {
                            use base64::Engine;

                            let image_bytes = base64::engine::general_purpose::STANDARD
                                .decode(image.source.as_bytes())
                                .context("failed to decode base64 image data")
                                .log_err()?;

                            BedrockImageBlock::builder()
                                .format(BedrockImageFormat::Png)
                                .source(BedrockImageSource::Bytes(BedrockBlob::new(image_bytes)))
                                .build()
                                .context("failed to build Bedrock image block")
                                .log_err()
                                .map(BedrockInnerContent::Image)
                        }
                    })
                    .collect();
                bedrock_message_content =
                    prepare_bedrock_content(bedrock_message_content, is_gpt_6_astra);
                if message.cache && supports_caching && !bedrock_message_content.is_empty() {
                    bedrock_message_content.push(BedrockInnerContent::CachePoint(
                        CachePointBlock::builder()
                            .r#type(CachePointType::Default)
                            .build()
                            .context("failed to build cache point block")?,
                    ));
                }
                let bedrock_role = match message.role {
                    Role::User => bedrock::BedrockRole::User,
                    Role::Assistant => bedrock::BedrockRole::Assistant,
                    Role::System => unreachable!("System role should never occur here"),
                };
                if bedrock_message_content.is_empty() {
                    continue;
                }

                if let Some(last_message) = new_messages.last_mut()
                    && last_message.role == bedrock_role
                {
                    last_message.content.extend(bedrock_message_content);
                    continue;
                }
                new_messages.push(
                    BedrockMessage::builder()
                        .role(bedrock_role)
                        .set_content(Some(bedrock_message_content))
                        .build()
                        .context("failed to build Bedrock message")?,
                );
            }
            Role::System => {
                if !system_message.is_empty() {
                    system_message.push_str("\n\n");
                }
                system_message.push_str(&message.string_contents());
            }
        }
    }

    let mut tool_spec: Vec<BedrockTool> = if supports_tool_use {
        request
            .tools
            .iter()
            .map(|tool| {
                let language_model::LanguageModelRequestToolInput::Function {
                    input_schema, ..
                } = &tool.input
                else {
                    anyhow::bail!("Bedrock does not support custom tools");
                };
                Ok(BedrockTool::ToolSpec(
                    BedrockToolSpec::builder()
                        .name(tool.name.clone())
                        .description(tool.description.clone())
                        .input_schema(BedrockToolInputSchema::Json(value_to_aws_document(
                            input_schema,
                        )))
                        .build()
                        .context("failed to build Bedrock tool spec")?,
                ))
            })
            .collect::<Result<_>>()?
    } else {
        Vec::new()
    };

    // Bedrock requires toolConfig when messages contain tool use/result blocks.
    // If no tools are defined but messages contain tool content (e.g., when
    // summarising a conversation that used tools), add a dummy tool to satisfy
    // the API requirement.
    if supports_tool_use && tool_spec.is_empty() && messages_contain_tool_content {
        tool_spec.push(BedrockTool::ToolSpec(
            BedrockToolSpec::builder()
                .name("_placeholder")
                .description("Placeholder tool to satisfy Bedrock API requirements when conversation history contains tool usage")
                .input_schema(BedrockToolInputSchema::Json(value_to_aws_document(
                    &serde_json::json!({"type": "object", "properties": {}}),
                )))
                .build()
                .context("failed to build placeholder tool spec")?,
        ));
    }

    if !tool_spec.is_empty() && supports_caching {
        tool_spec.push(BedrockTool::CachePoint(
            CachePointBlock::builder()
                .r#type(CachePointType::Default)
                .build()
                .context("failed to build cache point block")?,
        ));
    }

    let tool_choice = match request.tool_choice {
        Some(LanguageModelToolChoice::Auto) | None => {
            BedrockToolChoice::Auto(BedrockAutoToolChoice::builder().build())
        }
        Some(LanguageModelToolChoice::Any) => {
            BedrockToolChoice::Any(BedrockAnyToolChoice::builder().build())
        }
        Some(LanguageModelToolChoice::None) => {
            // For None, we still use Auto but will filter out tool calls in the response
            BedrockToolChoice::Auto(BedrockAutoToolChoice::builder().build())
        }
    };
    let tool_config = if tool_spec.is_empty() {
        None
    } else {
        Some(
            BedrockToolConfig::builder()
                .set_tools(Some(tool_spec))
                .tool_choice(tool_choice)
                .build()?,
        )
    };

    let mut system_blocks: Vec<BedrockSystemContentBlock> = Vec::new();
    if !system_message.is_empty() {
        system_blocks.push(BedrockSystemContentBlock::Text(system_message));
        if supports_caching {
            system_blocks.push(BedrockSystemContentBlock::CachePoint(
                CachePointBlock::builder()
                    .r#type(CachePointType::Default)
                    .build()
                    .context("failed to build system cache point block")?,
            ));
        }
    }

    let selected_effort = |default_effort| {
        // Astra, Fable 5.1, and Opus 5.5 keep reasoning enabled, so suppressed requests use the
        // default effort, matching the Anthropic and OpenAI providers.
        // <https://developers.openai.com/api/docs/guides/latest-model?model=gpt-6-astra>
        // <https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-fable-5-1.html>
        // <https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-opus-5-5.html>
        if !request.thinking_allowed {
            return default_effort;
        }
        request
            .thinking_effort
            .as_deref()
            .and_then(|effort| match effort {
                "low" => Some(bedrock::BedrockAdaptiveThinkingEffort::Low),
                "medium" => Some(bedrock::BedrockAdaptiveThinkingEffort::Medium),
                "high" => Some(bedrock::BedrockAdaptiveThinkingEffort::High),
                "xhigh" => Some(bedrock::BedrockAdaptiveThinkingEffort::XHigh),
                "max" => Some(bedrock::BedrockAdaptiveThinkingEffort::Max),
                _ => None,
            })
            .unwrap_or(default_effort)
    };
    let thinking = match thinking_mode {
        BedrockModelMode::Reasoning { effort } => Some(bedrock::Thinking::Reasoning {
            effort: selected_effort(effort),
        }),
        BedrockModelMode::AdaptiveThinking { effort }
            if request.thinking_allowed || always_adaptive =>
        {
            Some(bedrock::Thinking::Adaptive {
                effort: selected_effort(effort),
                binding_controls_beta: model
                    .rsplit_once("anthropic.")
                    .filter(|(_, model_id)| anthropic::binds_thinking_blocks_to_prefix(model_id))
                    .map(|_| anthropic::THINKING_BINDING_CONTROLS_BETA_HEADER.to_string()),
            })
        }
        BedrockModelMode::Thinking { budget_tokens } if request.thinking_allowed => {
            Some(bedrock::Thinking::Enabled { budget_tokens })
        }
        _ if !request.thinking_allowed
            && model.ends_with(ConverseModel::ClaudeOpus5.request_id()) =>
        {
            // Opus 5 defaults to adaptive thinking, so turning it off requires `disabled`.
            // <https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-opus-5.html>
            Some(bedrock::Thinking::Disabled)
        }
        _ => None,
    };
    let temperature = if always_adaptive || is_gpt_6_astra {
        None
    } else {
        request.temperature.or(default_temperature)
    };

    Ok(bedrock::Request {
        model,
        messages: new_messages,
        max_tokens: max_output_tokens,
        system: system_blocks,
        tools: tool_config,
        thinking,
        metadata: None,
        stop_sequences: Vec::new(),
        temperature,
        top_k: None,
        top_p: None,
        guardrail_identifier,
        guardrail_version,
    })
}

pub fn map_to_language_model_completion_events(
    events: Pin<Box<dyn Send + Stream<Item = Result<BedrockStreamingResponse, anyhow::Error>>>>,
    model: ConverseModel,
) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
    struct RawToolUse {
        id: String,
        name: String,
        input_json: String,
    }

    struct State {
        events: Pin<Box<dyn Send + Stream<Item = Result<BedrockStreamingResponse, anyhow::Error>>>>,
        tool_uses_by_index: HashMap<i32, RawToolUse>,
        redacted_thinking_by_index: HashMap<i32, Vec<u8>>,
        reasoning_model: Option<String>,
        emitted_tool_use: bool,
    }

    let model = converse_reasoning_model(model.request_id()).unwrap_or(model);
    let report_refusals = matches!(
        model,
        ConverseModel::ClaudeFable5_1 | ConverseModel::ClaudeFable5 | ConverseModel::Gpt6Astra
    );
    let preserve_redacted_thinking = matches!(
        model,
        ConverseModel::Gpt6Astra | ConverseModel::ClaudeFable5_1 | ConverseModel::ClaudeOpus5_5
    );
    let initial_state = State {
        events,
        tool_uses_by_index: HashMap::default(),
        redacted_thinking_by_index: HashMap::default(),
        reasoning_model: preserve_redacted_thinking.then(|| model.request_id().to_string()),
        emitted_tool_use: false,
    };

    futures::stream::unfold(initial_state, move |mut state| async move {
        match state.events.next().await {
            Some(event_result) => match event_result {
                Ok(event) => {
                    let result = match event {
                        ConverseStreamOutput::ContentBlockDelta(cb_delta) => match cb_delta.delta {
                            Some(ContentBlockDelta::Text(text)) => {
                                Some(Ok(LanguageModelCompletionEvent::Text(text)))
                            }
                            Some(ContentBlockDelta::ToolUse(tool_output)) => {
                                if let Some(tool_use) = state
                                    .tool_uses_by_index
                                    .get_mut(&cb_delta.content_block_index)
                                {
                                    tool_use.input_json.push_str(tool_output.input());
                                    if let Ok(input) = serde_json::from_str::<serde_json::Value>(
                                        &fix_streamed_json(&tool_use.input_json),
                                    ) {
                                        Some(Ok(LanguageModelCompletionEvent::ToolUse(
                                            LanguageModelToolUse {
                                                id: tool_use.id.clone().into(),
                                                name: tool_use.name.clone().into(),
                                                is_input_complete: false,
                                                raw_input: tool_use.input_json.clone(),
                                                input:
                                                    language_model::LanguageModelToolUseInput::Json(
                                                        input,
                                                    ),
                                                thought_signature: None,
                                            },
                                        )))
                                    } else {
                                        None
                                    }
                                } else {
                                    None
                                }
                            }
                            Some(ContentBlockDelta::ReasoningContent(thinking)) => match thinking {
                                ReasoningContentBlockDelta::Text(thoughts) => {
                                    Some(Ok(LanguageModelCompletionEvent::Thinking {
                                        text: thoughts,
                                        signature: None,
                                    }))
                                }
                                ReasoningContentBlockDelta::Signature(sig) => {
                                    Some(Ok(LanguageModelCompletionEvent::Thinking {
                                        text: "".into(),
                                        signature: Some(sig),
                                    }))
                                }
                                ReasoningContentBlockDelta::RedactedContent(redacted) => {
                                    if preserve_redacted_thinking {
                                        // A reasoning block can span multiple binary deltas.
                                        state
                                            .redacted_thinking_by_index
                                            .entry(cb_delta.content_block_index)
                                            .or_default()
                                            .extend(redacted.into_inner());
                                        None
                                    } else {
                                        let content = String::from_utf8(redacted.into_inner())
                                            .unwrap_or("REDACTED".to_string());
                                        Some(Ok(LanguageModelCompletionEvent::Thinking {
                                            text: content,
                                            signature: None,
                                        }))
                                    }
                                }
                                _ => None,
                            },
                            _ => None,
                        },
                        ConverseStreamOutput::ContentBlockStart(cb_start) => {
                            if let Some(ContentBlockStart::ToolUse(tool_start)) = cb_start.start {
                                state.tool_uses_by_index.insert(
                                    cb_start.content_block_index,
                                    RawToolUse {
                                        id: tool_start.tool_use_id,
                                        name: tool_start.name,
                                        input_json: String::new(),
                                    },
                                );
                            }
                            None
                        }
                        ConverseStreamOutput::MessageStart(_) => {
                            state.reasoning_model.as_ref().map(|id| {
                                Ok(LanguageModelCompletionEvent::ReasoningDetails(
                                    serde_json::json!({ "bedrock_model": id }),
                                ))
                            })
                        }
                        ConverseStreamOutput::ContentBlockStop(cb_stop) => state
                            .redacted_thinking_by_index
                            .remove(&cb_stop.content_block_index)
                            .map(|data| {
                                use base64::Engine;
                                Ok(LanguageModelCompletionEvent::RedactedThinking {
                                    data: base64::engine::general_purpose::STANDARD.encode(data),
                                })
                            })
                            .or_else(|| {
                                state
                                    .tool_uses_by_index
                                    .remove(&cb_stop.content_block_index)
                                    .map(|tool_use| {
                                        state.emitted_tool_use = true;

                                        let input = parse_tool_arguments(&tool_use.input_json)
                                            .unwrap_or_else(|_| Value::Object(Default::default()));

                                        Ok(LanguageModelCompletionEvent::ToolUse(
                                            LanguageModelToolUse {
                                                id: tool_use.id.into(),
                                                name: tool_use.name.into(),
                                                is_input_complete: true,
                                                raw_input: tool_use.input_json,
                                                input:
                                                    language_model::LanguageModelToolUseInput::Json(
                                                        input,
                                                    ),
                                                thought_signature: None,
                                            },
                                        ))
                                    })
                            }),
                        ConverseStreamOutput::Metadata(cb_meta) => cb_meta.usage.map(|metadata| {
                            Ok(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
                                input_tokens: metadata.input_tokens as u64,
                                output_tokens: metadata.output_tokens as u64,
                                cache_creation_input_tokens: metadata
                                    .cache_write_input_tokens
                                    .unwrap_or_default()
                                    as u64,
                                cache_read_input_tokens: metadata
                                    .cache_read_input_tokens
                                    .unwrap_or_default()
                                    as u64,
                            }))
                        }),
                        ConverseStreamOutput::MessageStop(message_stop) => {
                            let stop_reason = if report_refusals
                                && (message_stop.stop_reason == StopReason::ContentFiltered
                                    || message_stop.stop_reason.as_str() == "refusal")
                            {
                                language_model::StopReason::Refusal
                            } else if state.emitted_tool_use {
                                // Some models (e.g. Kimi) send EndTurn even when
                                // they've made tool calls. Trust the content over
                                // the stop reason.
                                language_model::StopReason::ToolUse
                            } else {
                                match message_stop.stop_reason {
                                    StopReason::ToolUse => language_model::StopReason::ToolUse,
                                    _ => language_model::StopReason::EndTurn,
                                }
                            };
                            Some(Ok(LanguageModelCompletionEvent::Stop(stop_reason)))
                        }
                        _ => None,
                    };

                    Some((result, state))
                }
                Err(err) => Some((
                    Some(Err(LanguageModelCompletionError::Other(anyhow!(err)))),
                    state,
                )),
            },
            None => None,
        }
    })
    .filter_map(|result| async move { result })
}

struct ConfigurationView {
    access_key_id_editor: Entity<InputField>,
    secret_access_key_editor: Entity<InputField>,
    session_token_editor: Entity<InputField>,
    bearer_token_editor: Entity<InputField>,
    state: Entity<State>,
    load_credentials_task: Option<Task<()>>,
    focus_handle: FocusHandle,
}

impl ConfigurationView {
    const PLACEHOLDER_ACCESS_KEY_ID_TEXT: &'static str = "XXXXXXXXXXXXXXXX";
    const PLACEHOLDER_SECRET_ACCESS_KEY_TEXT: &'static str =
        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    const PLACEHOLDER_SESSION_TOKEN_TEXT: &'static str = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
    const PLACEHOLDER_BEARER_TOKEN_TEXT: &'static str = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

    fn new(state: Entity<State>, window: &mut Window, cx: &mut Context<Self>) -> Self {
        let focus_handle = cx.focus_handle();

        cx.observe(&state, |_, _, cx| {
            cx.notify();
        })
        .detach();

        let access_key_id_editor = cx.new(|cx| {
            InputField::new(window, cx, Self::PLACEHOLDER_ACCESS_KEY_ID_TEXT)
                .label("Access Key ID")
                .tab_index(0)
                .tab_stop(true)
        });

        let secret_access_key_editor = cx.new(|cx| {
            InputField::new(window, cx, Self::PLACEHOLDER_SECRET_ACCESS_KEY_TEXT)
                .label("Secret Access Key")
                .tab_index(1)
                .tab_stop(true)
        });

        let session_token_editor = cx.new(|cx| {
            InputField::new(window, cx, Self::PLACEHOLDER_SESSION_TOKEN_TEXT)
                .label("Session Token (Optional)")
                .tab_index(2)
                .tab_stop(true)
        });

        let bearer_token_editor = cx.new(|cx| {
            InputField::new(window, cx, Self::PLACEHOLDER_BEARER_TOKEN_TEXT)
                .label("Bedrock API Key")
                .tab_index(3)
                .tab_stop(true)
        });

        let load_credentials_task = Some(cx.spawn({
            let state = state.clone();
            async move |this, cx| {
                if let Some(task) = Some(state.update(cx, |state, cx| state.authenticate(cx))) {
                    // We don't log an error, because "not signed in" is also an error.
                    let _ = task.await;
                }
                this.update(cx, |this, cx| {
                    this.load_credentials_task = None;
                    cx.notify();
                })
                .log_err();
            }
        }));

        Self {
            access_key_id_editor,
            secret_access_key_editor,
            session_token_editor,
            bearer_token_editor,
            state,
            load_credentials_task,
            focus_handle,
        }
    }

    fn save_credentials(
        &mut self,
        _: &menu::Confirm,
        _window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        let access_key_id = self
            .access_key_id_editor
            .read(cx)
            .text(cx)
            .trim()
            .to_string();
        let secret_access_key = self
            .secret_access_key_editor
            .read(cx)
            .text(cx)
            .trim()
            .to_string();
        let session_token = self
            .session_token_editor
            .read(cx)
            .text(cx)
            .trim()
            .to_string();
        let session_token = if session_token.is_empty() {
            None
        } else {
            Some(session_token)
        };
        let bearer_token = self
            .bearer_token_editor
            .read(cx)
            .text(cx)
            .trim()
            .to_string();
        let bearer_token = if bearer_token.is_empty() {
            None
        } else {
            Some(bearer_token)
        };

        let state = self.state.clone();
        cx.spawn(async move |_, cx| {
            state
                .update(cx, |state, cx| {
                    let credentials = BedrockCredentials {
                        access_key_id,
                        secret_access_key,
                        session_token,
                        bearer_token,
                    };

                    state.set_static_credentials(credentials, cx)
                })
                .await
        })
        .detach_and_log_err(cx);
    }

    fn reset_credentials(&mut self, window: &mut Window, cx: &mut Context<Self>) {
        self.access_key_id_editor
            .update(cx, |editor, cx| editor.set_text("", window, cx));
        self.secret_access_key_editor
            .update(cx, |editor, cx| editor.set_text("", window, cx));
        self.session_token_editor
            .update(cx, |editor, cx| editor.set_text("", window, cx));
        self.bearer_token_editor
            .update(cx, |editor, cx| editor.set_text("", window, cx));

        let state = self.state.clone();
        cx.spawn(async move |_, cx| state.update(cx, |state, cx| state.reset_auth(cx)).await)
            .detach_and_log_err(cx);
    }

    fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context<Self>) {
        window.focus_next(cx);
    }

    fn on_tab_prev(
        &mut self,
        _: &menu::SelectPrevious,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
        window.focus_prev(cx);
    }
}

impl Render for ConfigurationView {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let state = self.state.read(cx);
        let env_var_set = state.credentials_from_env;
        let auth = state.auth.clone();
        let settings_auth_method = state
            .settings
            .as_ref()
            .and_then(|s| s.authentication_method.clone());

        if self.load_credentials_task.is_some() {
            return div().child(Label::new("Loading credentials...")).into_any();
        }

        let configured_label = match &auth {
            Some(BedrockAuth::Automatic) => {
                "Using automatic credentials (AWS default chain)".into()
            }
            Some(BedrockAuth::NamedProfile { profile_name }) => {
                format!("Using AWS profile: {profile_name}")
            }
            Some(BedrockAuth::SingleSignOn { profile_name }) => {
                format!("Using AWS SSO profile: {profile_name}")
            }
            Some(BedrockAuth::IamCredentials { .. }) if env_var_set => {
                format!(
                    "Using IAM credentials from {} and {} environment variables",
                    ZED_BEDROCK_ACCESS_KEY_ID_VAR.name, ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.name
                )
            }
            Some(BedrockAuth::IamCredentials { .. }) => "Using IAM credentials".into(),
            Some(BedrockAuth::ApiKey { .. }) if env_var_set => {
                format!(
                    "Using Bedrock API Key from {} environment variable",
                    ZED_BEDROCK_BEARER_TOKEN_VAR.name
                )
            }
            Some(BedrockAuth::ApiKey { .. }) => "Using Bedrock API Key".into(),
            None => "Not authenticated".into(),
        };

        // Determine if credentials can be reset
        // Settings-derived auth (non-ApiKey) cannot be reset from UI
        let is_settings_derived = matches!(
            settings_auth_method,
            Some(BedrockAuthMethod::Automatic)
                | Some(BedrockAuthMethod::NamedProfile)
                | Some(BedrockAuthMethod::SingleSignOn)
        );

        let tooltip_label = if env_var_set {
            Some(format!(
                "To reset your credentials, unset the {}, {}, and {} or {} environment variables.",
                ZED_BEDROCK_ACCESS_KEY_ID_VAR.name,
                ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.name,
                ZED_BEDROCK_SESSION_TOKEN_VAR.name,
                ZED_BEDROCK_BEARER_TOKEN_VAR.name
            ))
        } else if is_settings_derived {
            Some(
                "Authentication method is configured in settings. Edit settings.json to change."
                    .to_string(),
            )
        } else {
            None
        };

        let credentials_control = if self.state.read(cx).is_authenticated() {
            ConfiguredApiCard::new("bedrock-reset", configured_label)
                .disabled(env_var_set || is_settings_derived)
                .on_click(cx.listener(|this, _, window, cx| this.reset_credentials(window, cx)))
                .when_some(tooltip_label, |this, label| this.tooltip_label(label))
                .into_any_element()
        } else {
            self.render_static_credentials_ui().into_any_element()
        };

        v_flex()
            .min_w_0()
            .w_full()
            .track_focus(&self.focus_handle)
            .on_action(cx.listener(Self::on_tab))
            .on_action(cx.listener(Self::on_tab_prev))
            .on_action(cx.listener(ConfigurationView::save_credentials))
            .gap_1()
            .child(Headline::new("Amazon Bedrock").size(HeadlineSize::Small))
            .child(
                Label::new(
                    "To use Zed's agent with Bedrock, you can set a custom authentication strategy through your settings file or use static credentials.",
                )
                .color(Color::Muted),
            )
            .child(
                Label::new("But first, to access models on AWS, you need to:")
                    .mt_1()
                    .color(Color::Muted),
            )
            .child(
                List::new()
                    .child(
                        ListBulletItem::new("")
                            .child(
                                Label::new(
                                    "Grant permissions to the strategy you'll use according to the:",
                                )
                                .color(Color::Muted),
                            )
                            .child(ButtonLink::new(
                                "Prerequisites",
                                "https://docs.aws.amazon.com/bedrock/latest/userguide/inference-prereq.html",
                            )),
                    )
                    .child(
                        ListBulletItem::new("")
                            .child(
                                Label::new("Select the models you would like access to:")
                                    .color(Color::Muted),
                            )
                            .child(ButtonLink::new(
                                "Bedrock Model Catalog",
                                "https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/model-catalog",
                            )),
                    ),
            )
            .child(credentials_control)
            .into_any()
    }
}

impl ConfigurationView {
    fn render_static_credentials_ui(&self) -> impl IntoElement {
        let list_item = List::new()
            .child(
                ListBulletItem::new("")
                    .child(
                        Label::new(
                            "For access keys: Create an IAM user in the AWS console with programmatic access",
                        )
                        .color(Color::Muted),
                    )
                    .child(ButtonLink::new(
                        "IAM Console",
                        "https://us-east-1.console.aws.amazon.com/iam/home?region=us-east-1#/users",
                    )),
            )
            .child(
                ListBulletItem::new("")
                    .child(
                        Label::new("For Bedrock API Keys: Generate an API key from the")
                            .color(Color::Muted),
                    )
                    .child(ButtonLink::new(
                        "Bedrock Console",
                        "https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-use.html",
                    )),
            )
            .child(
                ListBulletItem::new("")
                    .child(
                        Label::new("Attach the necessary Bedrock permissions to")
                            .color(Color::Muted),
                    )
                    .child(ButtonLink::new(
                        "this user",
                        "https://docs.aws.amazon.com/bedrock/latest/userguide/inference-prereq.html",
                    )),
            )
            .child(
                ListBulletItem::new(
                    "Enter either access keys OR a Bedrock API Key below (not both)",
                )
                .label_color(Color::Muted),
            );

        v_flex()
            .my_2()
            .tab_group()
            .gap_1p5()
            .child(Divider::horizontal())
            .child(Label::new("Static Credentials").mt_2())
            .child(
                Label::new(
                    "This method uses your AWS access key ID and secret access key, or a Bedrock API Key.",
                )
                .color(Color::Muted),
            )
            .child(list_item)
            .child(
                v_flex()
                    .gap_1()
                    .child(self.access_key_id_editor.clone())
                    .child(self.secret_access_key_editor.clone())
                    .child(self.session_token_editor.clone()),
            )
            .child(
                Label::new(format!(
                    "You can also set the {}, {} and {} environment variables (or {} for Bedrock API Key authentication) and restart Zed.",
                    ZED_BEDROCK_ACCESS_KEY_ID_VAR.name,
                    ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.name,
                    ZED_BEDROCK_REGION_VAR.name,
                    ZED_BEDROCK_BEARER_TOKEN_VAR.name
                ))
                .size(LabelSize::Small)
                .color(Color::Muted),
            )
            .child(
                Label::new(format!(
                    "Optionally, if your environment uses AWS CLI profiles, you can set {}; if it requires a custom endpoint, you can set {}; and if it requires a Session Token, you can set {}.",
                    ZED_AWS_PROFILE_VAR.name,
                    ZED_AWS_ENDPOINT_VAR.name,
                    ZED_BEDROCK_SESSION_TOKEN_VAR.name
                ))
                .size(LabelSize::Small)
                .color(Color::Muted)
                .mt_1()
                .mb_2p5(),
            )
            .child(Divider::horizontal())
            .child(Label::new("Using the API key").mt_2().mb_1())
            .child(self.bearer_token_editor.clone())
            .child(
                Label::new(format!(
                    "Region is configured via {} environment variable or settings.json (defaults to us-east-1).",
                    ZED_BEDROCK_REGION_VAR.name
                ))
                .size(LabelSize::Small)
                .color(Color::Muted)
            )
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use language_model::LanguageModelRequestMessage;
    use open_ai::responses::{
        ResponseFunctionToolCall, ResponseOutputMessage, ResponseReasoningItem,
    };

    fn into_bedrock_request(messages: Vec<LanguageModelRequestMessage>) -> bedrock::Request {
        into_bedrock(
            LanguageModelRequest {
                messages,
                ..Default::default()
            },
            "claude-sonnet-4-5".to_string(),
            Some(1.0),
            4096,
            BedrockModelMode::Default,
            true,
            true,
            None,
            None,
        )
        .unwrap()
    }

    #[gpui::test]
    fn mantle_model_replaces_converse_model_with_the_same_id(cx: &mut gpui::TestAppContext) {
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
            cx.set_global(settings_store);
            gpui_tokio::init(cx);
            let content = serde_json::json!({
                "language_models": {
                    "bedrock": {
                        "available_models": [{
                            "name": "shared-model",
                            "display_name": "Converse Shared",
                            "max_tokens": 1000,
                        }],
                        "mantle_available_models": [{
                            "name": "shared-model",
                            "display_name": "Mantle Shared",
                            "max_tokens": 2000,
                            "protocol": "chat_completions",
                        }],
                    }
                }
            })
            .to_string();
            cx.update_global::<SettingsStore, _>(|store, cx| {
                store
                    .set_user_settings(&content, cx)
                    .expect("test settings should parse");
            });
        });
        let provider = cx.update(|cx| {
            BedrockLanguageModelProvider::new(
                http_client::FakeHttpClient::with_404_response(),
                Arc::new(NoCredentialsProvider),
                cx,
            )
        });

        let shared = cx
            .update(|cx| provider.provided_models(cx))
            .into_iter()
            .filter(|model| model.id.0.as_ref() == "shared-model")
            .collect::<Vec<_>>();
        assert_eq!(shared.len(), 1, "each id should be offered once");
        assert_eq!(shared[0].name.0.as_ref(), "Mantle Shared");

        let config = cx
            .update(|cx| provider.config(&shared[0], cx))
            .expect("the offered model should resolve");
        assert!(matches!(
            config,
            BedrockModelConfig::Mantle(model) if model.display_name() == "Mantle Shared"
        ));
    }

    #[gpui::test]
    fn custom_converse_model_capabilities_come_from_settings(cx: &mut gpui::TestAppContext) {
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
            cx.set_global(settings_store);
            gpui_tokio::init(cx);
            let content = serde_json::json!({
                "language_models": {
                    "bedrock": {
                        "available_models": [{
                            "name": "us.anthropic.claude-custom-v1:0",
                            "display_name": "Custom Claude",
                            "max_tokens": 200000,
                            "supports_tools": true,
                            "supports_images": true,
                            "thinking": {
                                "budget_tokens": 8192
                            }
                        }],
                    }
                }
            })
            .to_string();
            cx.update_global::<SettingsStore, _>(|store, cx| {
                store
                    .set_user_settings(&content, cx)
                    .expect("test settings should parse");
            });
        });
        let provider = cx.update(|cx| {
            BedrockLanguageModelProvider::new(
                http_client::FakeHttpClient::with_404_response(),
                Arc::new(NoCredentialsProvider),
                cx,
            )
        });

        let custom = cx
            .update(|cx| provider.provided_models(cx))
            .into_iter()
            .find(|model| model.id.0.as_ref() == "us.anthropic.claude-custom-v1:0")
            .expect("custom converse model should be offered");
        assert!(custom.supports_tools);
        assert!(custom.supports_images);
        assert!(custom.supports_thinking);

        let config = cx
            .update(|cx| provider.config(&custom, cx))
            .expect("the offered model should resolve");
        match config {
            BedrockModelConfig::Converse(model) => {
                assert!(model.supports_tool_use());
                assert!(model.supports_images());
                assert!(model.supports_thinking());
                assert_eq!(
                    model.thinking_mode(),
                    BedrockModelMode::Thinking {
                        budget_tokens: Some(8192)
                    }
                );
            }
            BedrockModelConfig::Mantle(_) => panic!("expected a converse model"),
        }
    }

    #[test]
    fn thinking_settings_accept_bool_or_object() {
        assert_eq!(
            thinking_from_settings(Some(&settings::BedrockThinkingSettings::Enabled(true))),
            Some(bedrock::BedrockThinkingConfig {
                adaptive: false,
                has_xhigh: false,
                budget_tokens: None,
            })
        );
        assert_eq!(
            thinking_from_settings(Some(&settings::BedrockThinkingSettings::Enabled(false))),
            None
        );
        assert_eq!(
            thinking_from_settings(Some(&settings::BedrockThinkingSettings::Config(
                settings::BedrockThinkingConfigSettings {
                    adaptive: Some(true),
                    has_xhigh: Some(true),
                    budget_tokens: Some(10_000),
                }
            ))),
            Some(bedrock::BedrockThinkingConfig {
                adaptive: true,
                has_xhigh: true,
                budget_tokens: Some(10_000),
            })
        );
    }

    #[test]
    fn environment_bearer_token_prefers_the_bedrock_variable_like_the_aws_sdk() {
        let environment = |variables: &[(&str, &str)]| {
            let variables: HashMap<String, String> = variables
                .iter()
                .map(|(name, value)| (name.to_string(), value.to_string()))
                .collect();
            move |name: &str| variables.get(name).cloned()
        };

        assert_eq!(environment_bearer_token(environment(&[])), None);
        assert_eq!(
            environment_bearer_token(environment(&[("AWS_BEARER_TOKEN", "generic")])),
            Some("generic".to_string())
        );
        assert_eq!(
            environment_bearer_token(environment(&[
                ("AWS_BEARER_TOKEN", "generic"),
                ("AWS_BEARER_TOKEN_BEDROCK", "bedrock"),
            ])),
            Some("bedrock".to_string())
        );
        assert_eq!(
            environment_bearer_token(environment(&[
                ("AWS_BEARER_TOKEN", "generic"),
                ("AWS_BEARER_TOKEN_BEDROCK", ""),
            ])),
            Some(String::new()),
            "a set but empty Bedrock variable still wins, as in the SDK"
        );
    }

    #[gpui::test]
    async fn expiring_credentials_are_cached_per_auth_until_near_expiry(
        cx: &mut gpui::TestAppContext,
    ) {
        let provider = test_provider(cx);
        let auth = Some(BedrockAuth::NamedProfile {
            profile_name: "work".into(),
        });
        let other_auth = Some(BedrockAuth::NamedProfile {
            profile_name: "other".into(),
        });
        provider
            .state
            .update(cx, |state, _| state.set_auth(auth.clone()));

        // Resolved credentials that expire are cached and reused.
        let resolved = provider
            .resolve_request_auth_with(&cx.to_async(), no_environment, |_, _| {
                resolved_credentials("first", Some(Duration::from_secs(60 * 60)))
            })
            .await;
        assert_eq!(access_key_id(resolved), "first");
        let reused = provider
            .resolve_request_auth_with(&cx.to_async(), no_environment, |_, _| {
                resolved_credentials("second", None)
            })
            .await;
        assert_eq!(
            access_key_id(reused),
            "first",
            "unexpired credentials are reused"
        );

        // Credentials close to expiry, or cached for other auth, are replaced.
        for (cached_auth, expires_in, case) in [
            (&auth, Duration::from_secs(60), "near expiry"),
            (&other_auth, Duration::from_secs(60 * 60), "different auth"),
        ] {
            provider.state.update(cx, |state, _| {
                state.expiring_credentials = Some(ExpiringCredentials {
                    auth: cached_auth.clone(),
                    region: state.get_region(),
                    credentials: Credentials::new(
                        "cached",
                        "secret",
                        None,
                        Some(SystemTime::now() + expires_in),
                        "test",
                    ),
                });
            });
            let resolved = provider
                .resolve_request_auth_with(&cx.to_async(), no_environment, |_, _| {
                    resolved_credentials("fresh", None)
                })
                .await;
            assert_eq!(access_key_id(resolved), "fresh", "{case}");
        }

        // Credentials without an expiry are never cached.
        provider
            .state
            .update(cx, |state, _| state.expiring_credentials = None);
        provider
            .resolve_request_auth_with(&cx.to_async(), no_environment, |_, _| {
                resolved_credentials("static", None)
            })
            .await
            .expect("auth should resolve");
        assert!(
            provider
                .state
                .read_with(cx, |state, _| state.expiring_credentials.is_none()),
            "credentials without an expiry should not be cached"
        );

        // A resolution that completes after an auth change, even back to the
        // same auth, is not cached.
        let (send_credentials, receive_credentials) = futures::channel::oneshot::channel();
        let pending =
            provider.resolve_request_auth_with(&cx.to_async(), no_environment, |_, _| async move {
                receive_credentials
                    .await
                    .expect("the test sends credentials")
            });
        provider
            .state
            .update(cx, |state, _| state.set_auth(auth.clone()));
        assert!(
            send_credentials
                .send(resolved_credentials("stale", Some(Duration::from_secs(60 * 60))).await)
                .is_ok(),
            "the pending resolution should still be waiting"
        );
        pending.await.expect("auth should resolve");
        assert!(
            provider
                .state
                .read_with(cx, |state, _| state.expiring_credentials.is_none()),
            "credentials resolved for earlier auth should not be cached"
        );
    }

    #[gpui::test]
    async fn resolving_request_auth_prefers_the_environment_token_and_times_out(
        cx: &mut gpui::TestAppContext,
    ) {
        let provider = test_provider(cx);
        provider.state.update(cx, |state, _| {
            state.set_auth(Some(BedrockAuth::Automatic));
        });

        let request_auth = provider
            .resolve_request_auth_with(
                &cx.to_async(),
                |name| (name == "AWS_BEARER_TOKEN").then(|| "token".to_string()),
                |_, _| async { panic!("credentials should not be resolved") },
            )
            .await
            .expect("auth should resolve");
        assert!(matches!(
            request_auth,
            BedrockRequestAuth::ApiKey { api_key } if api_key == "token"
        ));

        // An API key configured in Zed takes precedence over the environment.
        provider.state.update(cx, |state, _| {
            state.set_auth(Some(BedrockAuth::ApiKey {
                api_key: "configured".into(),
            }));
        });
        let http_client = provider.http_client.clone();
        let request_auth = provider
            .resolve_request_auth_with(
                &cx.to_async(),
                |name| (name == "AWS_BEARER_TOKEN").then(|| "token".to_string()),
                move |auth, region| resolve_request_auth(http_client, auth, region),
            )
            .await
            .expect("auth should resolve");
        assert!(matches!(
            request_auth,
            BedrockRequestAuth::ApiKey { api_key } if api_key == "configured"
        ));

        let pending = provider.resolve_request_auth_with(&cx.to_async(), no_environment, |_, _| {
            futures::future::pending()
        });
        cx.executor().advance_clock(CREDENTIALS_LOAD_TIMEOUT);
        let error = pending.await.err().expect("resolution should time out");
        assert!(error.to_string().contains("timed out"), "{error}");
    }

    #[test]
    fn test_always_reasoning_model_defaults() -> Result<()> {
        for (model, expected_thinking) in [
            (
                ConverseModel::Gpt6Astra,
                serde_json::json!({"Reasoning": {"effort": "Medium"}}),
            ),
            (
                ConverseModel::ClaudeFable5_1,
                serde_json::json!({"Adaptive": {
                    "effort": "High", "binding_controls_beta": "thinking-binding-controls-2026-08-01"
                }}),
            ),
            (
                ConverseModel::ClaudeOpus5_5,
                serde_json::json!({"Adaptive": {
                    "effort": "High", "binding_controls_beta": "thinking-binding-controls-2026-08-01"
                }}),
            ),
        ] {
            for thinking_allowed in [true, false] {
                let request = into_bedrock(
                    LanguageModelRequest {
                        thinking_allowed,
                        ..Default::default()
                    },
                    model.cross_region_inference_id("us-east-1", false)?,
                    model.default_temperature(),
                    model.max_output_tokens(),
                    model.thinking_mode(),
                    model.supports_caching(),
                    model.supports_tool_use(),
                    None,
                    None,
                )?;
                assert_eq!(
                    serde_json::to_value(request.thinking)?,
                    expected_thinking,
                    "{} with thinking_allowed: {thinking_allowed}",
                    model.id()
                );
                assert_eq!(request.temperature, None);
            }
            assert!(!converse_language_model(&model).supports_disabling_thinking);
        }
        assert!(converse_language_model(&ConverseModel::ClaudeOpus4_8).supports_disabling_thinking);
        Ok(())
    }

    #[test]
    fn test_new_models_replay_only_their_own_encrypted_reasoning() -> Result<()> {
        use bedrock::bedrock_client::types::{
            ContentBlockDeltaEvent, ContentBlockStopEvent, MessageStartEvent,
        };

        let response = futures::stream::iter(vec![
            Ok(ConverseStreamOutput::MessageStart(
                MessageStartEvent::builder()
                    .role(bedrock::BedrockRole::Assistant)
                    .build()?,
            )),
            Ok(ConverseStreamOutput::ContentBlockDelta(
                ContentBlockDeltaEvent::builder()
                    .content_block_index(0)
                    .delta(ContentBlockDelta::ReasoningContent(
                        ReasoningContentBlockDelta::RedactedContent(BedrockBlob::new([0, 255])),
                    ))
                    .build()?,
            )),
            Ok(ConverseStreamOutput::ContentBlockStop(
                ContentBlockStopEvent::builder()
                    .content_block_index(0)
                    .build()?,
            )),
        ]);
        let events = futures::executor::block_on(
            map_to_language_model_completion_events(Box::pin(response), ConverseModel::Gpt6Astra)
                .collect::<Vec<_>>(),
        )
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?;
        let details = events.iter().find_map(|event| match event {
            LanguageModelCompletionEvent::ReasoningDetails(value) => Some(Arc::new(value.clone())),
            _ => None,
        });
        let redacted = events.iter().find_map(|event| match event {
            LanguageModelCompletionEvent::RedactedThinking { data } => Some(data.clone()),
            _ => None,
        });
        assert!(
            details.is_some(),
            "the stored reasoning must identify its model"
        );
        let redacted = redacted.expect("binary reasoning must survive streaming");

        let request_for = |model: ConverseModel, details: Option<Arc<Value>>, content| {
            into_bedrock(
                LanguageModelRequest {
                    messages: vec![LanguageModelRequestMessage {
                        role: Role::Assistant,
                        content,
                        cache: false,
                        reasoning_details: details,
                    }],
                    ..Default::default()
                },
                model.cross_region_inference_id("us-east-1", false)?,
                model.default_temperature(),
                model.max_output_tokens(),
                model.thinking_mode(),
                model.supports_caching(),
                model.supports_tool_use(),
                None,
                None,
            )
        };
        let own = request_for(
            ConverseModel::Gpt6Astra,
            details.clone(),
            vec![MessageContent::RedactedThinking(redacted.clone())],
        )?;
        assert!(matches!(
            own.messages[0].content().first(),
            Some(BedrockInnerContent::ReasoningContent(
                BedrockThinkingBlock::RedactedContent(data)
            )) if data.as_ref() == [0, 255]
        ));

        for (model, source) in [
            (ConverseModel::ClaudeFable5_1, details.clone()),
            (ConverseModel::Gpt6Astra, None),
            // The refusal fallback sends tagged history to a model without reasoning replay.
            (ConverseModel::ClaudeOpus4_8, details.clone()),
        ] {
            let request = request_for(
                model,
                source,
                vec![
                    MessageContent::RedactedThinking(redacted.clone()),
                    MessageContent::Thinking {
                        text: "foreign thinking".into(),
                        signature: Some("foreign signature".into()),
                    },
                    MessageContent::Text("Keep this answer".into()),
                ],
            )?;
            assert_eq!(request.messages[0].content().len(), 1);
            assert!(matches!(
                request.messages[0].content()[0],
                BedrockInnerContent::Text(_)
            ));
        }
        let malformed = request_for(
            ConverseModel::Gpt6Astra,
            details,
            vec![
                MessageContent::RedactedThinking("not base64!".into()),
                MessageContent::Text("Keep this answer".into()),
            ],
        )?;
        assert_eq!(malformed.messages[0].content().len(), 1);
        Ok(())
    }

    #[test]
    fn test_opus_5_5_replays_only_its_own_reasoning() -> Result<()> {
        use bedrock::bedrock_client::types::MessageStartEvent;

        let response = futures::stream::iter(vec![Ok(ConverseStreamOutput::MessageStart(
            MessageStartEvent::builder()
                .role(bedrock::BedrockRole::Assistant)
                .build()?,
        ))]);
        let events = futures::executor::block_on(
            map_to_language_model_completion_events(
                Box::pin(response),
                ConverseModel::ClaudeOpus5_5,
            )
            .collect::<Vec<_>>(),
        )
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?;
        let details = events.iter().find_map(|event| match event {
            LanguageModelCompletionEvent::ReasoningDetails(value) => Some(Arc::new(value.clone())),
            _ => None,
        });
        assert!(details.is_some());

        for (model, replays_reasoning) in [
            (ConverseModel::ClaudeOpus5_5, true),
            (ConverseModel::ClaudeFable5_1, false),
            (ConverseModel::ClaudeOpus4_8, false),
        ] {
            let request = into_bedrock(
                LanguageModelRequest {
                    messages: vec![LanguageModelRequestMessage {
                        role: Role::Assistant,
                        content: vec![
                            MessageContent::Thinking {
                                text: "thinking".into(),
                                signature: Some("signature".into()),
                            },
                            MessageContent::Text("answer".into()),
                        ],
                        cache: false,
                        reasoning_details: details.clone(),
                    }],
                    ..Default::default()
                },
                model.cross_region_inference_id("us-east-1", false)?,
                model.default_temperature(),
                model.max_output_tokens(),
                model.thinking_mode(),
                model.supports_caching(),
                model.supports_tool_use(),
                None,
                None,
            )?;
            assert_eq!(
                matches!(
                    request.messages[0].content().first(),
                    Some(BedrockInnerContent::ReasoningContent(_))
                ),
                replays_reasoning,
                "{}",
                model.id()
            );
        }
        Ok(())
    }

    #[test]
    fn test_astra_parallel_tool_results_precede_their_images() -> Result<()> {
        let results = (1..=2)
            .map(|index| {
                let mut content = Vec::new();
                if index == 1 {
                    content.push(LanguageModelToolResultContent::Text("Result 1".into()));
                }
                content.push(LanguageModelToolResultContent::Image(
                    language_model::LanguageModelImage {
                        source: "iVBORw0KGgo=".into(),
                    },
                ));
                MessageContent::ToolResult(language_model::LanguageModelToolResult {
                    tool_use_id: format!("tool-{index}").into(),
                    tool_name: "view_image".into(),
                    is_error: false,
                    content,
                    output: None,
                })
            })
            .collect();
        let request = into_bedrock(
            LanguageModelRequest {
                messages: vec![LanguageModelRequestMessage {
                    role: Role::User,
                    content: results,
                    cache: false,
                    reasoning_details: None,
                }],
                ..Default::default()
            },
            "us.openai.gpt-6-astra".into(),
            None,
            128_000,
            BedrockModelMode::Default,
            false,
            true,
            None,
            None,
        )?;
        let kinds = request.messages[0]
            .content()
            .iter()
            .map(|content| match content {
                BedrockInnerContent::ToolResult(_) => "result",
                BedrockInnerContent::Image(_) => "image",
                _ => "other",
            })
            .collect::<Vec<_>>();
        assert_eq!(kinds, ["result", "result", "image", "image"]);
        assert!(matches!(
            &request.messages[0].content()[1],
            BedrockInnerContent::ToolResult(result)
                if matches!(result.content().first(), Some(BedrockToolResultContentBlock::Text(_)))
        ));
        Ok(())
    }

    #[test]
    fn test_converse_refusals_and_fable_forced_tool_use() -> Result<()> {
        let fable = ConverseModel::ClaudeFable5_1;
        let earlier_fable = ConverseModel::ClaudeFable5;
        assert!(!converse_language_model(&fable).tool_choice_support.any);
        assert!(
            converse_language_model(&earlier_fable)
                .tool_choice_support
                .any
        );
        let forced = into_bedrock(
            LanguageModelRequest {
                tool_choice: Some(LanguageModelToolChoice::Any),
                ..Default::default()
            },
            fable.cross_region_inference_id("us-east-1", false)?,
            fable.default_temperature(),
            fable.max_output_tokens(),
            fable.thinking_mode(),
            fable.supports_caching(),
            fable.supports_tool_use(),
            None,
            None,
        );
        assert!(forced.is_err());

        for model in [fable, earlier_fable, ConverseModel::Gpt6Astra] {
            for reason in [StopReason::from("refusal"), StopReason::ContentFiltered] {
                let response = futures::stream::iter(vec![Ok(ConverseStreamOutput::MessageStop(
                    bedrock::bedrock_client::types::MessageStopEvent::builder()
                        .stop_reason(reason)
                        .build()?,
                ))]);
                let events = futures::executor::block_on(
                    map_to_language_model_completion_events(Box::pin(response), model.clone())
                        .collect::<Vec<_>>(),
                )
                .into_iter()
                .collect::<Result<Vec<_>, _>>()?;
                assert_eq!(
                    events,
                    [LanguageModelCompletionEvent::Stop(
                        language_model::StopReason::Refusal
                    )]
                );
            }
        }
        Ok(())
    }

    #[test]
    fn test_custom_fable_5_1_entry_matches_the_built_in_model() -> Result<()> {
        use bedrock::bedrock_client::types::MessageStartEvent;

        let custom = ConverseModel::Custom {
            name: "us.anthropic.claude-fable-5-1".into(),
            max_tokens: 1_000_000,
            display_name: None,
            max_output_tokens: Some(128_000),
            default_temperature: None,
            cache_configuration: None,
            supports_tool_use: Some(true),
            supports_images: Some(true),
            thinking: Some(bedrock::BedrockThinkingConfig {
                adaptive: true,
                has_xhigh: true,
                budget_tokens: None,
            }),
        };
        assert!(!converse_language_model(&custom).tool_choice_support.any);

        let response = futures::stream::iter(vec![Ok(ConverseStreamOutput::MessageStart(
            MessageStartEvent::builder()
                .role(bedrock::BedrockRole::Assistant)
                .build()?,
        ))]);
        let events = futures::executor::block_on(
            map_to_language_model_completion_events(Box::pin(response), custom.clone())
                .collect::<Vec<_>>(),
        )
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?;
        let details = events.iter().find_map(|event| match event {
            LanguageModelCompletionEvent::ReasoningDetails(value) => Some(Arc::new(value.clone())),
            _ => None,
        });

        let request = into_bedrock(
            LanguageModelRequest {
                messages: vec![LanguageModelRequestMessage {
                    role: Role::Assistant,
                    content: vec![
                        MessageContent::Thinking {
                            text: "thinking".into(),
                            signature: Some("signature".into()),
                        },
                        MessageContent::Text("answer".into()),
                    ],
                    cache: false,
                    reasoning_details: details,
                }],
                ..Default::default()
            },
            custom.cross_region_inference_id("us-east-1", false)?,
            custom.default_temperature(),
            custom.max_output_tokens(),
            custom.thinking_mode(),
            custom.supports_caching(),
            custom.supports_tool_use(),
            None,
            None,
        )?;
        assert!(matches!(
            request.messages[0].content().first(),
            Some(BedrockInnerContent::ReasoningContent(_))
        ));
        Ok(())
    }

    #[test]
    fn test_thinking_disallowed_sends_explicit_opt_out_only_on_opus_5() {
        // Claude Opus 5 runs adaptive thinking by default when the `thinking`
        // field is omitted, so suppressing thinking requires an explicit
        // `disabled` opt-out. Earlier Claude models treat omission as "off".
        for (model, expects_explicit_opt_out, output_limit, expected_output) in [
            ("us.anthropic.claude-opus-5", true, None, 128_000),
            ("global.anthropic.claude-opus-5", true, Some(8192), 8192),
            (
                "us.anthropic.claude-opus-4-8",
                false,
                Some(256_000),
                128_000,
            ),
        ] {
            let request = into_bedrock(
                LanguageModelRequest {
                    messages: vec![LanguageModelRequestMessage {
                        role: Role::User,
                        content: vec![MessageContent::Text("Hi".into())],
                        cache: false,
                        reasoning_details: None,
                    }],
                    thinking_allowed: false,
                    max_output_tokens: output_limit,
                    ..Default::default()
                },
                model.to_string(),
                Some(1.0),
                128_000,
                BedrockModelMode::AdaptiveThinking {
                    effort: bedrock::BedrockAdaptiveThinkingEffort::High,
                },
                true,
                true,
                None,
                None,
            )
            .unwrap();

            assert_eq!(request.max_tokens, expected_output);
            if expects_explicit_opt_out {
                assert!(
                    matches!(request.thinking, Some(bedrock::Thinking::Disabled)),
                    "{model} should send an explicit thinking opt-out"
                );
            } else {
                assert!(
                    request.thinking.is_none(),
                    "{model} should omit the thinking field entirely"
                );
            }
        }
    }

    #[test]
    fn test_custom_models_omit_temperature_unless_configured() {
        let messages = vec![LanguageModelRequestMessage {
            role: Role::User,
            content: vec![MessageContent::Text("Hi".into())],
            cache: false,
            reasoning_details: None,
        }];

        let omitted = into_bedrock(
            LanguageModelRequest {
                messages: messages.clone(),
                ..Default::default()
            },
            "us.xai.grok-4.6".to_string(),
            None,
            4096,
            BedrockModelMode::Default,
            false,
            true,
            None,
            None,
        )
        .unwrap();
        assert_eq!(omitted.temperature, None);

        let configured = into_bedrock(
            LanguageModelRequest {
                messages,
                ..Default::default()
            },
            "us.anthropic.claude-sonnet-4-7".to_string(),
            Some(0.7),
            4096,
            BedrockModelMode::Default,
            false,
            true,
            None,
            None,
        )
        .unwrap();
        assert_eq!(configured.temperature, Some(0.7));
    }

    #[test]
    fn test_opus_5_5_rejects_only_forced_tool_choice() -> Result<()> {
        let opus_5_5 = ConverseModel::ClaudeOpus5_5;
        let custom = ConverseModel::Custom {
            name: "us.anthropic.claude-opus-5-5".into(),
            max_tokens: 1_000_000,
            display_name: None,
            max_output_tokens: Some(128_000),
            default_temperature: None,
            cache_configuration: None,
            supports_tool_use: Some(true),
            supports_images: Some(true),
            thinking: None,
        };
        for model in [&opus_5_5, &custom] {
            let language_model = converse_language_model(model);
            assert!(language_model.supports_tools);
            assert!(language_model.tool_choice_support.auto);
            assert!(language_model.tool_choice_support.none);
            assert!(
                !language_model.tool_choice_support.any,
                "{} rejects forced tool use",
                model.id()
            );
        }

        let forced = into_bedrock(
            LanguageModelRequest {
                tool_choice: Some(LanguageModelToolChoice::Any),
                ..Default::default()
            },
            opus_5_5.cross_region_inference_id("us-east-1", false)?,
            opus_5_5.default_temperature(),
            opus_5_5.max_output_tokens(),
            opus_5_5.thinking_mode(),
            opus_5_5.supports_caching(),
            opus_5_5.supports_tool_use(),
            None,
            None,
        );
        assert!(forced.is_err());

        for model in [
            ConverseModel::ClaudeOpus5,
            ConverseModel::ClaudeFable5,
            ConverseModel::NovaPro,
        ] {
            assert!(
                converse_language_model(&model).tool_choice_support.any,
                "{} should still support forced tool use",
                model.id()
            );
        }
        Ok(())
    }

    #[test]
    fn test_opus_5_5_omits_sampling_controls() {
        // Opus 5.5's always-on adaptive thinking rejects sampling controls, so
        // its request must omit temperature (top_k/top_p are always unset).
        // Other adaptive-thinking Claude models keep their default temperature.
        for (model, expects_temperature) in [
            ("global.anthropic.claude-opus-5-5", false),
            ("us.anthropic.claude-opus-5-5", false),
            ("us.anthropic.claude-opus-5", true),
            ("us.anthropic.claude-sonnet-5", true),
        ] {
            let request = into_bedrock(
                LanguageModelRequest {
                    messages: vec![LanguageModelRequestMessage {
                        role: Role::User,
                        content: vec![MessageContent::Text("Hi".into())],
                        cache: false,
                        reasoning_details: None,
                    }],
                    ..Default::default()
                },
                model.to_string(),
                Some(1.0),
                128_000,
                BedrockModelMode::AdaptiveThinking {
                    effort: bedrock::BedrockAdaptiveThinkingEffort::High,
                },
                true,
                true,
                None,
                None,
            )
            .unwrap();

            assert_eq!(request.top_k, None, "{model} must not send top_k");
            assert_eq!(request.top_p, None, "{model} must not send top_p");
            if expects_temperature {
                assert_eq!(
                    request.temperature,
                    Some(1.0),
                    "{model} should send its default temperature"
                );
            } else {
                assert_eq!(
                    request.temperature, None,
                    "{model} must omit temperature because adaptive thinking is always on"
                );
            }
        }
    }

    #[test]
    fn test_cache_marked_message_that_filters_to_empty_is_dropped() {
        let request = into_bedrock_request(vec![
            LanguageModelRequestMessage {
                role: Role::User,
                content: vec![MessageContent::Text("What's the weather?".into())],
                cache: false,
                reasoning_details: None,
            },
            LanguageModelRequestMessage {
                role: Role::Assistant,
                content: vec![MessageContent::Thinking {
                    text: "Let me think about this...".into(),
                    signature: None,
                }],
                cache: true,
                reasoning_details: None,
            },
            LanguageModelRequestMessage {
                role: Role::User,
                content: vec![MessageContent::Text("Summarize this conversation.".into())],
                cache: false,
                reasoning_details: None,
            },
        ]);

        for message in &request.messages {
            assert!(
                message
                    .content()
                    .iter()
                    .any(|block| !matches!(block, BedrockInnerContent::CachePoint(_))),
                "message must not consist solely of cache points: {:?}",
                message
            );
        }
        assert!(
            request
                .messages
                .iter()
                .all(|message| *message.role() == bedrock::BedrockRole::User),
            "the assistant message stripped to empty content should be dropped entirely"
        );
    }

    #[test]
    fn test_cache_marked_message_with_content_gets_cache_point() {
        let request = into_bedrock_request(vec![LanguageModelRequestMessage {
            role: Role::User,
            content: vec![MessageContent::Text("What's the weather?".into())],
            cache: true,
            reasoning_details: None,
        }]);

        assert_eq!(request.messages.len(), 1);
        assert!(
            matches!(
                request.messages[0].content().last(),
                Some(BedrockInnerContent::CachePoint(_))
            ),
            "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"));
    }

    fn mantle_message_item(id: &str) -> ResponseOutputItem {
        mantle_message_item_with_phase(id, None)
    }

    fn mantle_message_item_with_phase(id: &str, phase: Option<&str>) -> ResponseOutputItem {
        ResponseOutputItem::Message(ResponseOutputMessage {
            id: Some(id.to_string()),
            content: Vec::new(),
            role: Some("assistant".to_string()),
            status: Some("in_progress".to_string()),
            phase: phase.map(str::to_string),
        })
    }

    fn mantle_function_call_item(id: &str, name: &str, call_id: &str) -> ResponseOutputItem {
        ResponseOutputItem::FunctionCall(ResponseFunctionToolCall {
            id: Some(id.to_string()),
            arguments: String::new(),
            call_id: Some(call_id.to_string()),
            name: Some(name.to_string()),
            status: Some("in_progress".to_string()),
        })
    }

    fn mantle_reasoning_item(id: &str) -> ResponseOutputItem {
        ResponseOutputItem::Reasoning(ResponseReasoningItem {
            id: Some(id.to_string()),
            summary: Vec::new(),
            content: Vec::new(),
            encrypted_content: None,
            status: Some("in_progress".to_string()),
        })
    }

    fn text_delta(item_id: &str, output_index: usize, delta: &str) -> OpenAiResponseStreamEvent {
        OpenAiResponseStreamEvent::OutputTextDelta {
            item_id: item_id.to_string(),
            output_index,
            content_index: Some(0),
            delta: delta.to_string(),
        }
    }

    fn item_added(output_index: usize, item: ResponseOutputItem) -> OpenAiResponseStreamEvent {
        OpenAiResponseStreamEvent::OutputItemAdded {
            output_index,
            sequence_number: None,
            item,
        }
    }

    fn item_done(output_index: usize, item: ResponseOutputItem) -> OpenAiResponseStreamEvent {
        OpenAiResponseStreamEvent::OutputItemDone {
            output_index,
            sequence_number: None,
            item,
        }
    }

    fn map_mantle_response_events(
        events: Vec<OpenAiResponseStreamEvent>,
    ) -> Vec<LanguageModelCompletionEvent> {
        let mut mapper = MantleResponseEventMapper::new();
        events
            .into_iter()
            .flat_map(|event| mapper.map_event(event))
            .map(|event| event.expect("Mantle response event should map successfully"))
            .collect()
    }

    // Keeps only StartMessage and Text events so phase/reasoning tests can assert on
    // message boundaries without depending on incidental ReasoningDetails metadata.
    fn start_messages_and_texts(
        events: Vec<LanguageModelCompletionEvent>,
    ) -> Vec<LanguageModelCompletionEvent> {
        events
            .into_iter()
            .filter(|event| {
                matches!(
                    event,
                    LanguageModelCompletionEvent::StartMessage { .. }
                        | LanguageModelCompletionEvent::Text(_)
                )
            })
            .collect()
    }

    #[test]
    fn mantle_response_mapper_coalesces_cumulative_message_snapshots() {
        let first_message = mantle_message_item("msg_1");
        let second_message = mantle_message_item("msg_2");
        let events = map_mantle_response_events(vec![
            OpenAiResponseStreamEvent::OutputItemAdded {
                output_index: 0,
                sequence_number: None,
                item: first_message.clone(),
            },
            OpenAiResponseStreamEvent::OutputTextDelta {
                item_id: "msg_1".to_string(),
                output_index: 0,
                content_index: Some(0),
                delta: "Plan: rename".to_string(),
            },
            OpenAiResponseStreamEvent::OutputItemDone {
                output_index: 0,
                sequence_number: None,
                item: first_message,
            },
            OpenAiResponseStreamEvent::OutputItemAdded {
                output_index: 1,
                sequence_number: None,
                item: second_message.clone(),
            },
            OpenAiResponseStreamEvent::OutputTextDelta {
                item_id: "msg_2".to_string(),
                output_index: 1,
                content_index: Some(0),
                delta: "Plan: rename".to_string(),
            },
            OpenAiResponseStreamEvent::OutputTextDelta {
                item_id: "msg_2".to_string(),
                output_index: 1,
                content_index: Some(0),
                delta: " and regenerate".to_string(),
            },
            OpenAiResponseStreamEvent::OutputItemDone {
                output_index: 1,
                sequence_number: None,
                item: second_message,
            },
            OpenAiResponseStreamEvent::Completed {
                response: open_ai::responses::ResponseSummary::default(),
            },
        ]);

        assert_eq!(
            events,
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan: rename".to_string()),
                LanguageModelCompletionEvent::Text(" and regenerate".to_string()),
                LanguageModelCompletionEvent::Stop(language_model::StopReason::EndTurn),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_preserves_independent_messages() {
        let first_message = mantle_message_item("msg_1");
        let second_message = mantle_message_item("msg_2");
        let events = map_mantle_response_events(vec![
            OpenAiResponseStreamEvent::OutputItemAdded {
                output_index: 0,
                sequence_number: None,
                item: first_message.clone(),
            },
            OpenAiResponseStreamEvent::OutputTextDelta {
                item_id: "msg_1".to_string(),
                output_index: 0,
                content_index: Some(0),
                delta: "Plan".to_string(),
            },
            OpenAiResponseStreamEvent::OutputItemDone {
                output_index: 0,
                sequence_number: None,
                item: first_message,
            },
            OpenAiResponseStreamEvent::OutputItemAdded {
                output_index: 1,
                sequence_number: None,
                item: second_message.clone(),
            },
            OpenAiResponseStreamEvent::OutputTextDelta {
                item_id: "msg_2".to_string(),
                output_index: 1,
                content_index: Some(0),
                delta: "Final answer".to_string(),
            },
            OpenAiResponseStreamEvent::OutputItemDone {
                output_index: 1,
                sequence_number: None,
                item: second_message,
            },
        ]);

        assert_eq!(
            events,
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_2".to_string(),
                },
                LanguageModelCompletionEvent::Text("Final answer".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_coalesces_chained_cumulative_snapshots() {
        // Each merge must thread `previous_message`/`emitted_text_length`
        // through to the next.
        let first_message = mantle_message_item("msg_1");
        let second_message = mantle_message_item("msg_2");
        let third_message = mantle_message_item("msg_3");
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan"),
            item_done(0, first_message),
            item_added(1, second_message.clone()),
            text_delta("msg_2", 1, "Plan and go"),
            item_done(1, second_message),
            item_added(2, third_message.clone()),
            text_delta("msg_3", 2, "Plan and go further"),
            item_done(2, third_message),
        ]);

        assert_eq!(
            events,
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
                LanguageModelCompletionEvent::Text(" and go".to_string()),
                LanguageModelCompletionEvent::Text(" further".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_keeps_message_state_across_content_events() {
        let first_message = mantle_message_item("msg_1");
        let second_message = mantle_message_item("msg_2");
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan"),
            item_done(0, first_message),
            item_added(1, second_message.clone()),
            OpenAiResponseStreamEvent::ContentPartAdded {
                item_id: "msg_2".to_string(),
                output_index: 1,
                content_index: 0,
                part: serde_json::json!({"type": "output_text", "text": ""}),
            },
            text_delta("msg_2", 1, "Plan"),
            text_delta("msg_2", 1, " and continue"),
            OpenAiResponseStreamEvent::OutputTextDone {
                item_id: "msg_2".to_string(),
                output_index: 1,
                content_index: Some(0),
                text: "Plan and continue".to_string(),
            },
            OpenAiResponseStreamEvent::ContentPartDone {
                item_id: "msg_2".to_string(),
                output_index: 1,
                content_index: 0,
                part: serde_json::json!({"type": "output_text", "text": "Plan and continue"}),
            },
            item_done(1, second_message),
        ]);

        assert_eq!(
            events,
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
                LanguageModelCompletionEvent::Text(" and continue".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_resets_on_non_message_item_done() {
        let first_message = mantle_message_item("msg_1");
        let second_message = mantle_message_item("msg_2");
        let tool_call = mantle_function_call_item("call_1", "get_weather", "server_call_1");
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan"),
            item_done(0, first_message),
            item_done(1, tool_call),
            item_added(2, second_message.clone()),
            text_delta("msg_2", 2, "Plan continued"),
            item_done(2, second_message),
        ]);

        assert_eq!(
            start_messages_and_texts(events),
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_2".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan continued".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_keeps_post_tool_message_separate_when_extending_prior_text() {
        // A tool call sits between two messages. Even though the second message's
        // text happens to extend the first message's text, the tool call is a hard
        // boundary and the second message must remain a separate, visible message.
        let first_message = mantle_message_item("msg_1");
        let tool_call = mantle_function_call_item("call_1", "get_weather", "server_call_1");
        let second_message = mantle_message_item("msg_2");
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan"),
            item_done(0, first_message),
            item_added(1, tool_call.clone()),
            OpenAiResponseStreamEvent::FunctionCallArgumentsDone {
                item_id: "call_1".to_string(),
                output_index: 1,
                arguments: "{\"city\":\"Boston\"}".to_string(),
                sequence_number: None,
            },
            item_done(1, tool_call),
            item_added(2, second_message.clone()),
            text_delta("msg_2", 2, "Plan continued"),
            item_done(2, second_message),
        ]);

        assert_eq!(
            events,
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
                LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
                    id: language_model::LanguageModelToolUseId::from("server_call_1"),
                    name: Arc::<str>::from("get_weather"),
                    is_input_complete: true,
                    input: language_model::LanguageModelToolUseInput::Json(
                        serde_json::json!({"city": "Boston"}),
                    ),
                    raw_input: "{\"city\":\"Boston\"}".to_string(),
                    thought_signature: None,
                }),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_2".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan continued".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_treats_reasoning_as_collapse_boundary() {
        // A reasoning item between two messages breaks adjacency, so the second
        // message is emitted independently even though it repeats the first's text.
        let first_message = mantle_message_item("msg_1");
        let reasoning = mantle_reasoning_item("rsn_1");
        let second_message = mantle_message_item("msg_2");
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan"),
            item_done(0, first_message),
            item_added(1, reasoning.clone()),
            item_done(1, reasoning),
            item_added(2, second_message.clone()),
            text_delta("msg_2", 2, "Plan"),
            item_done(2, second_message),
        ]);

        assert_eq!(
            start_messages_and_texts(events),
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_2".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_preserves_equal_and_shrinking_messages() {
        // Equal and strict-prefix (shrinking) adjacent messages must not be dropped:
        // they are emitted as independent messages rather than collapsed away.
        let first_message = mantle_message_item("msg_1");
        let second_message = mantle_message_item("msg_2");
        let third_message = mantle_message_item("msg_3");
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Hello world"),
            item_done(0, first_message),
            // Equal to the previous message.
            item_added(1, second_message.clone()),
            text_delta("msg_2", 1, "Hello world"),
            item_done(1, second_message),
            // Strict prefix of (shorter than) the previous message.
            item_added(2, third_message.clone()),
            text_delta("msg_3", 2, "Hello"),
            item_done(2, third_message),
        ]);

        assert_eq!(
            events,
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Hello world".to_string()),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_2".to_string(),
                },
                LanguageModelCompletionEvent::Text("Hello world".to_string()),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_3".to_string(),
                },
                LanguageModelCompletionEvent::Text("Hello".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_keeps_different_phase_messages_separate() {
        // Two messages share a text prefix but have different phases; only same-phase
        // strict extensions collapse, so the second message stays visible.
        let first_message = mantle_message_item_with_phase("msg_1", Some("commentary"));
        let second_message = mantle_message_item_with_phase("msg_2", Some("final_answer"));
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan: rename"),
            item_done(0, first_message),
            item_added(1, second_message.clone()),
            text_delta("msg_2", 1, "Plan: rename and regenerate"),
            item_done(1, second_message),
        ]);

        assert_eq!(
            start_messages_and_texts(events),
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan: rename".to_string()),
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_2".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan: rename and regenerate".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_coalesces_same_phase_strict_extension() {
        // Same phase, strict extension: the replayed prefix is collapsed and only the
        // new suffix is emitted, so no second StartMessage appears.
        let first_message = mantle_message_item_with_phase("msg_1", Some("final_answer"));
        let second_message = mantle_message_item_with_phase("msg_2", Some("final_answer"));
        let events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan: rename"),
            item_done(0, first_message),
            item_added(1, second_message.clone()),
            text_delta("msg_2", 1, "Plan: rename"),
            text_delta("msg_2", 1, " and regenerate"),
            item_done(1, second_message),
        ]);

        assert_eq!(
            start_messages_and_texts(events),
            vec![
                LanguageModelCompletionEvent::StartMessage {
                    message_id: "msg_1".to_string(),
                },
                LanguageModelCompletionEvent::Text("Plan: rename".to_string()),
                LanguageModelCompletionEvent::Text(" and regenerate".to_string()),
            ]
        );
    }

    #[test]
    fn mantle_response_mapper_does_not_duplicate_reasoning_details_on_merge() {
        // Merging a second message into the first must not emit any additional
        // phase/reasoning metadata events beyond what the first message alone would
        // have produced, since the metadata can't have changed by merging.
        fn reasoning_details_count(events: &[LanguageModelCompletionEvent]) -> usize {
            events
                .iter()
                .filter(|event| matches!(event, LanguageModelCompletionEvent::ReasoningDetails(_)))
                .count()
        }

        let first_message = mantle_message_item_with_phase("msg_1", Some("final_answer"));
        let baseline_events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan: rename"),
            item_done(0, first_message.clone()),
        ]);

        let second_message = mantle_message_item_with_phase("msg_2", Some("final_answer"));
        let merged_events = map_mantle_response_events(vec![
            item_added(0, first_message.clone()),
            text_delta("msg_1", 0, "Plan: rename"),
            item_done(0, first_message),
            item_added(1, second_message.clone()),
            text_delta("msg_2", 1, "Plan: rename"),
            text_delta("msg_2", 1, " and regenerate"),
            item_done(1, second_message),
        ]);

        assert_eq!(
            reasoning_details_count(&merged_events),
            reasoning_details_count(&baseline_events),
        );
    }

    #[test]
    fn test_builtin_mantle_models_support_thinking() {
        assert!(MantleModel::Gpt5_6Sol.supports_thinking());
        assert!(MantleModel::Gpt5_6Terra.supports_thinking());
        assert!(MantleModel::Gpt5_6Luna.supports_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_6Sol),
            Some(ReasoningEffort::Medium)
        );
        assert_eq!(
            mantle_default_reasoning_effort(&MantleModel::Gpt5_6Terra),
            Some(ReasoningEffort::Medium)
        );
        assert_eq!(
            mantle_default_reasoning_effort(&MantleModel::Gpt5_6Luna),
            Some(ReasoningEffort::Medium)
        );
        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(),
            &PROVIDER_ID,
        )
        .unwrap();

        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,
            &PROVIDER_ID,
        )
        .unwrap();

        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());
    }

    struct NoCredentialsProvider;

    impl CredentialsProvider for NoCredentialsProvider {
        fn read_credentials<'a>(
            &'a self,
            _url: &'a str,
            _cx: &'a AsyncApp,
        ) -> Pin<Box<dyn Future<Output = Result<Option<(String, Vec<u8>)>>> + 'a>> {
            Box::pin(async { Ok(None) })
        }

        fn write_credentials<'a>(
            &'a self,
            _url: &'a str,
            _username: &'a str,
            _password: &'a [u8],
            _cx: &'a AsyncApp,
        ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a>> {
            Box::pin(async { Ok(()) })
        }

        fn delete_credentials<'a>(
            &'a self,
            _url: &'a str,
            _cx: &'a AsyncApp,
        ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a>> {
            Box::pin(async { Ok(()) })
        }
    }

    fn test_provider(cx: &mut gpui::TestAppContext) -> BedrockLanguageModelProvider {
        cx.executor().allow_parking();
        cx.update(|cx| {
            let settings_store = SettingsStore::test(cx);
            cx.set_global(settings_store);
            gpui_tokio::init(cx);
            BedrockLanguageModelProvider::new(
                http_client::FakeHttpClient::with_404_response(),
                Arc::new(NoCredentialsProvider),
                cx,
            )
        })
    }

    fn no_environment(_: &str) -> Option<String> {
        None
    }

    async fn resolved_credentials(
        access_key_id: &str,
        expires_in: Option<Duration>,
    ) -> Result<BedrockRequestAuth> {
        Ok(BedrockRequestAuth::SigV4 {
            credentials: Credentials::new(
                access_key_id,
                "secret",
                None,
                expires_in.map(|expires_in| SystemTime::now() + expires_in),
                "test",
            ),
        })
    }

    fn access_key_id(request_auth: Result<BedrockRequestAuth>) -> String {
        match request_auth.expect("auth should resolve") {
            BedrockRequestAuth::SigV4 { credentials } => credentials.access_key_id().to_string(),
            BedrockRequestAuth::ApiKey { .. } => panic!("expected SigV4 credentials"),
        }
    }
}