feat(translation): support Bedrock Converse as a native wire format

crates/protocol/src/format.rs

@@ -20,6 +20,9 @@ pub enum WireFormat {
     /// OpenAI Responses API.
     #[serde(rename = "openai_responses")]
     OpenAiResponses,
+    /// Amazon Bedrock Converse API; the host owns AWS transport framing.
+    #[serde(rename = "bedrock_converse")]
+    BedrockConverse,
 }
 
 impl WireFormat {
@@ -29,6 +32,7 @@ impl WireFormat {
             Self::OpenAiChat => "openai_chat",
             Self::AnthropicMessages => "anthropic_messages",
             Self::OpenAiResponses => "openai_responses",
+            Self::BedrockConverse => "bedrock_converse",
         }
     }
 }

crates/protocol/src/stream.rs

@@ -504,9 +504,12 @@ fn parse_tool_arguments(arguments: &str) -> Value {
 /// to a normalized [`StopReason`], covering the common OpenAI and Anthropic spellings.
 fn stop_reason_from_str(reason: Option<&str>) -> StopReason {
     match reason {
-        Some("length" | "max_tokens") => StopReason::MaxTokens,
+        Some("length" | "max_tokens" | "model_context_window_exceeded") => StopReason::MaxTokens,
         Some("tool_calls" | "function_call" | "tool_use") => StopReason::ToolUse,
-        Some("content_filter") => StopReason::ContentFilter,
+        Some("content_filter" | "content_filtered" | "guardrail_intervened") => {
+            StopReason::ContentFilter
+        }
+        Some("malformed_model_output" | "malformed_tool_use") => StopReason::Error,
         Some("stop" | "end_turn" | "stop_sequence") | None => StopReason::EndTurn,
         Some(_) => StopReason::Unknown,
     }

crates/switchyard-server/src/lib.rs

@@ -1389,13 +1389,15 @@ impl ApiError {
                     "message": self.message.clone(),
                 }
             }),
-            WireFormat::OpenAiChat | WireFormat::OpenAiResponses => json!({
-                "error": {
-                    "message": self.message.clone(),
-                    "type": self.error_type,
-                    "code": self.code,
-                }
-            }),
+            WireFormat::OpenAiChat | WireFormat::OpenAiResponses | WireFormat::BedrockConverse => {
+                json!({
+                    "error": {
+                        "message": self.message.clone(),
+                        "type": self.error_type,
+                        "code": self.code,
+                    }
+                })
+            }
         };
         let mut response = (self.status, Json(body)).into_response();
         response

crates/switchyard-server/src/sse.rs

@@ -82,6 +82,10 @@ fn frame_event(
     let data = redactor.json(serde_json::to_string(&value)?);
     match target_format {
         WireFormat::OpenAiChat => Ok(Event::default().data(data)),
+        WireFormat::BedrockConverse => Err(serde_json::Error::io(std::io::Error::new(
+            std::io::ErrorKind::Unsupported,
+            "Bedrock requires AWS EventStream framing, unavailable on SSE endpoints",
+        ))),
         WireFormat::AnthropicMessages | WireFormat::OpenAiResponses => {
             let event_type = value
                 .get("type")
@@ -95,7 +99,7 @@ fn frame_event(
 
 fn error_event(target_format: WireFormat, message: String, redactor: &Redactor) -> Event {
     match target_format {
-        WireFormat::OpenAiChat => Event::default().data(
+        WireFormat::OpenAiChat | WireFormat::BedrockConverse => Event::default().data(
             redactor.json(
                 json!({
                     "error": {

crates/switchyard-translation/README.md

@@ -1,11 +1,46 @@
 # switchyard-translation
 
-Pure Rust translation between OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages
-request, response, and streaming formats.
+Pure Rust translation between OpenAI Chat Completions, OpenAI Responses, Anthropic Messages,
+and Amazon Bedrock Converse request, response, and streaming formats.
 
 The crate translates through provider-neutral LLM types from `switchyard-protocol` and does not
 depend on provider SDKs, HTTP servers, Python, or FFI bindings.
 
+## Bedrock Converse
+
+Use `WireFormat::BedrockConverse` (serialized as `bedrock_converse`) with `TranslationEngine`
+for buffered bodies. Text, system instructions, function tools and tool results, common inference
+settings, inline images, stop reasons, and cache-token usage have neutral mappings. JSON tool results
+become serialized JSON text when normalized; same-format preservation retains their original JSON.
+Native controls such as guardrails and additional model fields survive same-format request encoding.
+Cross-format projection diagnoses their loss and rejects it under strict loss policy.
+Normalized encoding merges consecutive messages with the same Bedrock role in content order.
+Tool history requires tool definitions. Disabling tools with history retains the required config
+and reports a lossy conversion; strict loss policy rejects it. Without history, disabling tools
+omits the config. Same-format preservation keeps the original request body.
+Context-window exhaustion maps to the neutral token-limit stop reason so other formats mark the
+response incomplete. Same-format preservation retains the original Bedrock stop reason.
+
+ConverseStream codecs operate on the JSON union events after the host removes and validates AWS
+EventStream framing. Feed those events to `decode_event_stream`, then use `encode_stream` for target
+JSON events. `decode_stream` is for SSE bytes and rejects Bedrock. A Bedrock stream must include
+`messageStart`, closed content blocks, `messageStop`, and terminal `metadata` with reported usage;
+truncation, malformed events, or provider exceptions fail the stream. Encoding requires reported
+input and output tokens; an absent total is derived from those counts and cache details.
+
+Same-format preserved events replay unchanged, including native reasoning signatures. Aggregated
+Bedrock reasoning preserves signature and redacted-content fragments. Translation to Anthropic
+streams omits Bedrock signature fragments while retaining visible reasoning and answer text;
+Bedrock redacted reasoning cannot be mapped and fails the stream. Encoding Bedrock rejects
+foreign opaque reasoning stream details, including Anthropic signatures. Tool arguments
+may precede their ID and name; parallel calls are serialized into Bedrock blocks. A tool block
+cannot resume after other content closes it. Encoding Bedrock rejects unsupported foreign media and provider-specific built-in tool
+history.
+
+The host owns the model ID in the request URL, AWS credentials, SigV4 signing, regions, retries,
+and binary EventStream framing. This crate adds no Bedrock HTTP client or server endpoint. Adding
+the public `WireFormat` member requires downstream exhaustive matches to handle the new variant.
+
 ## License
 
 Licensed under the Apache License, Version 2.0. See the

crates/switchyard-translation/src/codecs/anthropic/stream.rs

@@ -211,7 +211,18 @@ fn encode_anthropic_stream(
             }));
             out
         }
-        LlmResponseChunk::ReasoningDetailsDelta { text, .. } => {
+        LlmResponseChunk::ReasoningDetailsDelta { text, details, .. } => {
+            if details.iter().any(|detail| {
+                detail.get("type").and_then(Value::as_str) == Some("bedrock.redacted_content")
+            }) {
+                return encode_anthropic_stream(
+                    state,
+                    LlmResponseChunk::DecodeError {
+                        message: "Bedrock redacted reasoning has no Anthropic stream mapping"
+                            .into(),
+                    },
+                );
+            }
             if text.is_empty() {
                 return Vec::new();
             }

crates/switchyard-translation/src/codecs/bedrock.rs

@@ -0,0 +1,12 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Bedrock Converse buffered bodies and ConverseStream event payloads.
+
+mod buffered;
+pub(crate) mod stream;
+
+pub use buffered::BedrockConverseCodec;
+pub use stream::BedrockConverseStreamCodec;
+
+pub(crate) use buffered::request_projection_diagnostics;