mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-19 15:10:34 +01:00
5d3f275cbf
## Background: Amazon Bedrock Guardrails
AWS Bedrock Guardrails enables configurable safety and compliance
controls for generative AI applications:
- Evaluates both user inputs and model responses against policies.
:contentReference[oaicite:8]{index=8}
- Can block or filter content based on harmful categories, denied
topics, PII, or hallucination criteria.
:contentReference[oaicite:9]{index=9}
- Guardrails are applied during inference API calls by specifying
`guardrailIdentifier` and `guardrailVersion` in the request.
:contentReference[oaicite:10]{index=10}
Relevant AWS documentation:
- User Guide:
https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails.html
- How Guardrails Works:
https://docs.aws.amazon.com/bedrock/latest/userguide/guardrails-how.html
- API Reference (GuardrailConfiguration):
https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GuardrailConfiguration.html
Some AWS environments enforce IAM policies that require a guardrail to
be specified on every Bedrock API call (via a `StringEquals` condition
on `bedrock:GuardrailIdentifier`). Without this, Zed returns
`AccessDenied` and Bedrock models are completely unusable in those
environments.
This adds two optional settings, `guardrail_identifier` and
`guardrail_version`, to the Bedrock provider config. When set, a
`GuardrailStreamConfiguration` is attached to every `converse_stream`
request. When unset, behaviour is identical to before.
```json
{
"language_models": {
"bedrock": {
"guardrail_identifier": "arn:aws:bedrock:us-east-1:123456789012:guardrail/abc123",
"guardrail_version": "DRAFT"
}
}
}
```
`guardrail_version` defaults to `"DRAFT"` if omitted.
Release Notes:
- agent: Added `guardrail_identifier` and `guardrail_version` settings
for AWS Bedrock, enabling use in environments where IAM policies require
a guardrail on all model requests
---------
Co-authored-by: Bennet Bo Fenner <bennetbo@gmx.de>
130 lines
5.8 KiB
Rust
130 lines
5.8 KiB
Rust
use std::sync::Arc;
|
|
|
|
use collections::HashMap;
|
|
use settings::RegisterSetting;
|
|
|
|
use crate::provider::{
|
|
anthropic::AnthropicSettings, bedrock::AmazonBedrockSettings, cloud::ZedDotDevSettings,
|
|
deepseek::DeepSeekSettings, google::GoogleSettings, lmstudio::LmStudioSettings,
|
|
mistral::MistralSettings, ollama::OllamaSettings, open_ai::OpenAiSettings,
|
|
open_ai_compatible::OpenAiCompatibleSettings, open_router::OpenRouterSettings,
|
|
opencode::OpenCodeSettings, vercel_ai_gateway::VercelAiGatewaySettings, x_ai::XAiSettings,
|
|
};
|
|
|
|
#[derive(Debug, RegisterSetting)]
|
|
pub struct AllLanguageModelSettings {
|
|
pub anthropic: AnthropicSettings,
|
|
pub bedrock: AmazonBedrockSettings,
|
|
pub deepseek: DeepSeekSettings,
|
|
pub google: GoogleSettings,
|
|
pub lmstudio: LmStudioSettings,
|
|
pub mistral: MistralSettings,
|
|
pub ollama: OllamaSettings,
|
|
pub opencode: OpenCodeSettings,
|
|
pub open_router: OpenRouterSettings,
|
|
pub openai: OpenAiSettings,
|
|
pub openai_compatible: HashMap<Arc<str>, OpenAiCompatibleSettings>,
|
|
pub vercel_ai_gateway: VercelAiGatewaySettings,
|
|
pub x_ai: XAiSettings,
|
|
pub zed_dot_dev: ZedDotDevSettings,
|
|
}
|
|
|
|
impl settings::Settings for AllLanguageModelSettings {
|
|
const PRESERVED_KEYS: Option<&'static [&'static str]> = Some(&["version"]);
|
|
|
|
fn from_settings(content: &settings::SettingsContent) -> Self {
|
|
let language_models = content.language_models.clone().unwrap();
|
|
let anthropic = language_models.anthropic.unwrap();
|
|
let bedrock = language_models.bedrock.unwrap();
|
|
let deepseek = language_models.deepseek.unwrap();
|
|
let google = language_models.google.unwrap();
|
|
let lmstudio = language_models.lmstudio.unwrap();
|
|
let mistral = language_models.mistral.unwrap();
|
|
let ollama = language_models.ollama.unwrap();
|
|
let opencode = language_models.opencode.unwrap();
|
|
let open_router = language_models.open_router.unwrap();
|
|
let openai = language_models.openai.unwrap();
|
|
let openai_compatible = language_models.openai_compatible.unwrap();
|
|
let vercel_ai_gateway = language_models.vercel_ai_gateway.unwrap();
|
|
let x_ai = language_models.x_ai.unwrap();
|
|
let zed_dot_dev = language_models.zed_dot_dev.unwrap();
|
|
Self {
|
|
anthropic: AnthropicSettings {
|
|
api_url: anthropic.api_url.unwrap(),
|
|
available_models: anthropic.available_models.unwrap_or_default(),
|
|
},
|
|
bedrock: AmazonBedrockSettings {
|
|
available_models: bedrock.available_models.unwrap_or_default(),
|
|
region: bedrock.region,
|
|
endpoint: bedrock.endpoint_url, // todo(should be api_url)
|
|
profile_name: bedrock.profile,
|
|
role_arn: None, // todo(was never a setting for this...)
|
|
authentication_method: bedrock.authentication_method.map(Into::into),
|
|
allow_global: bedrock.allow_global,
|
|
guardrail_identifier: bedrock.guardrail_identifier,
|
|
guardrail_version: bedrock.guardrail_version,
|
|
},
|
|
deepseek: DeepSeekSettings {
|
|
api_url: deepseek.api_url.unwrap(),
|
|
available_models: deepseek.available_models.unwrap_or_default(),
|
|
},
|
|
google: GoogleSettings {
|
|
api_url: google.api_url.unwrap(),
|
|
available_models: google.available_models.unwrap_or_default(),
|
|
},
|
|
lmstudio: LmStudioSettings {
|
|
api_url: lmstudio.api_url.unwrap(),
|
|
available_models: lmstudio.available_models.unwrap_or_default(),
|
|
},
|
|
mistral: MistralSettings {
|
|
api_url: mistral.api_url.unwrap(),
|
|
available_models: mistral.available_models.unwrap_or_default(),
|
|
},
|
|
ollama: OllamaSettings {
|
|
api_url: ollama.api_url.unwrap(),
|
|
auto_discover: ollama.auto_discover.unwrap_or(true),
|
|
available_models: ollama.available_models.unwrap_or_default(),
|
|
context_window: ollama.context_window,
|
|
},
|
|
opencode: OpenCodeSettings {
|
|
api_url: opencode.api_url.unwrap(),
|
|
available_models: opencode.available_models.unwrap_or_default(),
|
|
show_zen_models: opencode.show_zen_models.unwrap_or(true),
|
|
show_go_models: opencode.show_go_models.unwrap_or(true),
|
|
show_free_models: opencode.show_free_models.unwrap_or(true),
|
|
},
|
|
open_router: OpenRouterSettings {
|
|
api_url: open_router.api_url.unwrap(),
|
|
available_models: open_router.available_models.unwrap_or_default(),
|
|
},
|
|
openai: OpenAiSettings {
|
|
api_url: openai.api_url.unwrap(),
|
|
available_models: openai.available_models.unwrap_or_default(),
|
|
},
|
|
openai_compatible: openai_compatible
|
|
.into_iter()
|
|
.map(|(key, value)| {
|
|
(
|
|
key,
|
|
OpenAiCompatibleSettings {
|
|
api_url: value.api_url,
|
|
available_models: value.available_models,
|
|
},
|
|
)
|
|
})
|
|
.collect(),
|
|
vercel_ai_gateway: VercelAiGatewaySettings {
|
|
api_url: vercel_ai_gateway.api_url.unwrap(),
|
|
available_models: vercel_ai_gateway.available_models.unwrap_or_default(),
|
|
},
|
|
x_ai: XAiSettings {
|
|
api_url: x_ai.api_url.unwrap(),
|
|
available_models: x_ai.available_models.unwrap_or_default(),
|
|
},
|
|
zed_dot_dev: ZedDotDevSettings {
|
|
available_models: zed_dot_dev.available_models.unwrap_or_default(),
|
|
},
|
|
}
|
|
}
|
|
}
|