Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
fix(llm-client): drop unsigned thinking blocks on the Anthropic leg (#285)
sabhatinas31e0afb200da
diff --git a/crates/libsy-llm-client/src/client.rs b/crates/libsy-llm-client/src/client.rsindex 925dbdc6b..f64259c3d 100644--- a/crates/libsy-llm-client/src/client.rs+++ b/crates/libsy-llm-client/src/client.rs@@ -203,6 +203,7 @@ impl TranslatingLlmClient {// deliberately via `extra_body`.if matches!(backend, Backend::Anthropic(_)) {strip_anthropic_incompatible_fields(&mut body);+ strip_unsigned_thinking_blocks(&mut body);}merge_extra_body(&mut body, backend.extra_body());if matches!(backend, Backend::Anthropic(_)) {@@ -677,6 +678,58 @@ fn strip_anthropic_incompatible_fields(body: &mut Value) {}}+// Removes replayed `thinking` blocks that carry no signature.+//+// Anthropic requires signed thinking blocks on replay. A router can serve earlier+// turns of a session from an OpenAI-format target whose thinking blocks are+// unsigned, so the Anthropic leg must drop them or the upstream rejects the+// request. Bedrock enforces this (surfacing as a SigV4 signature mismatch) where+// Azure-hosted Anthropic currently does not. Mirrors `switchyard-components`'+// `strip_unsigned_thinking_blocks`.+fn strip_unsigned_thinking_blocks(body: &mut Value) {+ let Value::Object(object) = body else {+ return;+ };+ let Some(Value::Array(messages)) = object.get_mut("messages") else {+ return;+ };+ for message in messages {+ strip_unsigned_thinking_from_message(message);+ }+}++// Drops unsigned thinking blocks from one message, collapsing content that ends+// up empty to an empty string so the message stays valid.+fn strip_unsigned_thinking_from_message(message: &mut Value) {+ let Value::Object(message) = message else {+ return;+ };+ let Some(Value::Array(blocks)) = message.get("content") else {+ return;+ };+ if !blocks.iter().any(is_unsigned_thinking_block) {+ return;+ }+ let Some(Value::Array(blocks)) = message.get_mut("content") else {+ return;+ };+ blocks.retain(|block| !is_unsigned_thinking_block(block));+ if blocks.is_empty() {+ message.insert("content".to_string(), Value::String(String::new()));+ }+}++// A thinking block is unsigned when `signature` is absent or empty.+fn is_unsigned_thinking_block(block: &Value) -> bool {+ if block.get("type").and_then(Value::as_str) != Some("thinking") {+ return false;+ }+ !matches!(+ block.get("signature").and_then(Value::as_str),+ Some(signature) if !signature.is_empty()+ )+}+// Applies target defaults without overriding fields supplied by the caller.fn merge_extra_body(body: &mut Value, extra_body: &BTreeMap<String, Value>) {let Value::Object(object) = body else {@@ -1228,6 +1281,81 @@ mod tests {Ok(())}+ // A weak OpenAI-format tier emits thinking blocks with no signature. Replaying+ // them to Anthropic is rejected (Bedrock reports it as a SigV4 mismatch), so+ // the Anthropic leg must drop them while keeping signed ones.+ #[tokio::test]+ async fn anthropic_requests_drop_unsigned_thinking_blocks()+ -> std::result::Result<(), Box<dyn Error + Sync + Send + 'static>> {+ let server = MockServer::start().await;+ Mock::given(method("POST"))+ .and(path("/v1/messages"))+ .and(|request: &wiremock::Request| {+ let body: Value = serde_json::from_slice(&request.body).unwrap_or(Value::Null);+ let messages = body.get("messages").and_then(Value::as_array).cloned();+ let Some(messages) = messages else {+ return false;+ };+ // The unsigned block is gone, the signed one survives, and the+ // message whose only block was unsigned is not left with an empty+ // content array.+ let blocks: Vec<&Value> = messages+ .iter()+ .filter_map(|message| message.get("content"))+ .filter_map(Value::as_array)+ .flatten()+ .collect();+ let thinking: Vec<&&Value> = blocks+ .iter()+ .filter(|block| block.get("type").and_then(Value::as_str) == Some("thinking"))+ .collect();+ thinking.len() == 1+ && thinking[0].get("signature").and_then(Value::as_str) == Some("sig-abc")+ && messages+ .iter()+ .all(|message| message.get("content") != Some(&json!([])))+ })+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "id": "msg_1",+ "type": "message",+ "role": "assistant",+ "model": "claude",+ "content": [{"type": "text", "text": "ok"}],+ "stop_reason": "end_turn",+ "usage": {"input_tokens": 1, "output_tokens": 1}+ })))+ .mount(&server)+ .await;++ let client = TranslatingLlmClient::new(&anthropic_map(&server.uri()))?;+ let raw = json!({+ "model": "client-facing",+ "max_tokens": 7,+ "messages": [+ {"role": "user", "content": "fix the build"},+ {"role": "assistant", "content": [+ {"type": "thinking", "thinking": "weak tier reasoning", "signature": ""}+ ]},+ {"role": "assistant", "content": [+ {"type": "thinking", "thinking": "signed reasoning", "signature": "sig-abc"},+ {"type": "text", "text": "here goes"}+ ]},+ {"role": "user", "content": "continue"}+ ]+ });++ client+ .call_rewrite_model_raw(+ Context::default(),+ raw,+ None,+ Some("claude"),+ WireFormat::AnthropicMessages,+ )+ .await?;+ Ok(())+ }+// A router can serve earlier turns from an OpenAI target and later turns from// an Anthropic one, so the Anthropic leg must drop OpenAI-only fields the// caller keeps sending or the upstream rejects the whole request.