llmshim 0.2.0__tar.gz → 0.2.2__tar.gz

{llmshim-0.2.0 → llmshim-0.2.2}/CLAUDE.md

@@ -70,7 +70,7 @@ Image content blocks are translated between providers automatically. Users can s
 
 ### Multi-model conversations
 
-Each provider sanitizes messages from other providers in `transform_request`. OpenAI's `annotations`/`refusal` stripped for Anthropic/Gemini. `reasoning_content` stripped for all. Tool calls normalized to OpenAI format in responses, translated back per-provider on input.
+Each provider sanitizes messages from other providers in `transform_request`. OpenAI's `annotations`/`refusal` stripped for Anthropic/Gemini. `reasoning_content` is stripped by other providers, but **Anthropic reconstructs a native `thinking` block** from `reasoning_content` + `reasoning_signature` (and `redacted_thinking` from `redacted_reasoning_content`) as the first block of the assistant turn, so extended-thinking + tool-use round-trips losslessly (surfaced on responses incl. streaming; opaque signatures are stripped by other providers so they never leak cross-provider; no signature → still stripped). Symmetric to the tool-call `thought_signature` round-trip. Tool calls normalized to OpenAI format in responses, translated back per-provider on input.
 
 ### Provider extension namespaces (`x-anthropic`, `x-gemini`)
 
@@ -81,7 +81,7 @@ Callers pass provider-specific controls under these keys. Each provider copies w
 
 ### Unified reasoning controls
 
-Two knobs work across every provider: `reasoning_effort` (`none|low|medium|high|xhigh|max`) and `reasoning_mode` (`standard|pro`). Each provider transform maps them to its native dialect, **clamping to the nearest tier the target model accepts** (all boundaries verified live — e.g. `max` is native only on OpenAI gpt-5.6; Anthropic 4.6 rejects `xhigh` but has `max`; Gemini's enum tops out at `high`; xAI grok-4.20 models reject any reasoning param). `mode: "pro"` is native on OpenAI gpt-5.6/-pro models (`reasoning.mode`), emulated as a one-tier effort bump elsewhere; explicit `none` always wins. Native passthrough (`x-openai.reasoning`, `x-anthropic.thinking`, `x-gemini.thinkingConfig`) bypasses the mapping entirely and always takes precedence. **Full per-provider mapping tables: `docs/src/guides/reasoning.md`** — update it and the pinning tests in `tests/unit_*.rs` together whenever a mapping changes.
+Two knobs work across every provider: `reasoning_effort` (`none|low|medium|high|xhigh|max`) and `reasoning_mode` (`standard|pro`). A third, `reasoning_summary` (`auto|none`), controls reasoning-text visibility → Anthropic `thinking.display` (`auto`→`summarized`, the default when `reasoning_effort` is present so newer models like Sonnet 5 / Opus 4.7-4.8 return reasoning text instead of the API-default `omitted`; `none`→`omitted` for lower latency). Applies to both the adaptive and pre-4.6 enabled thinking builders; a caller-supplied `thinking` block bypasses it. Each provider transform maps them to its native dialect, **clamping to the nearest tier the target model accepts** (all boundaries verified live — e.g. `max` is native only on OpenAI gpt-5.6; Anthropic 4.6 rejects `xhigh` but has `max`; Gemini's enum tops out at `high`; xAI grok-4.20 models reject any reasoning param). `mode: "pro"` is native on OpenAI gpt-5.6/-pro models (`reasoning.mode`), emulated as a one-tier effort bump elsewhere; explicit `none` always wins. Native passthrough (`x-openai.reasoning`, `x-anthropic.thinking`, `x-gemini.thinkingConfig`) bypasses the mapping entirely and always takes precedence. **Full per-provider mapping tables: `docs/src/guides/reasoning.md`** — update it and the pinning tests in `tests/unit_*.rs` together whenever a mapping changes.
 
 ### Tool format translation
 

{llmshim-0.2.0 → llmshim-0.2.2}/Cargo.lock

@@ -958,7 +958,7 @@ checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "llmshim"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "async-stream",
  "async-trait",

{llmshim-0.2.0 → llmshim-0.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "llmshim"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 description = "Blazing fast LLM API translation layer in pure Rust"
 license = "MIT"

{llmshim-0.2.0 → llmshim-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llmshim
-Version: 0.2.0
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{llmshim-0.2.0 → llmshim-0.2.2}/docs/src/reference/request-fields.md

@@ -23,6 +23,7 @@ renamed or reshaped for the selected provider; unsupported controls are omitted.
 | `stop` | array of strings | Conditional, mapped | Passed as `stop` to Anthropic or mapped to Gemini `stopSequences`; omitted by OpenAI/xAI |
 | `reasoning_effort` | string | Portable, mapped/clamped | Unified effort from `none` through `max` |
 | `reasoning_mode` | string | Portable, mapped/clamped | `standard` or `pro` |
+| `reasoning_summary` | string | Anthropic (`auto`\|`none`) | Reasoning visibility → Anthropic `thinking.display`; `auto`→`summarized` (default with `reasoning_effort`), `none`→`omitted` for lower latency |
 | `tools` | array | Portable, mapped | OpenAI Chat Completions function schema translated to native tools |
 | `tool_choice` | string or object | Portable, mapped | Translated where the provider supports tool choice |
 | `x-openai` | object | Native passthrough | Fields copied to an OpenAI Responses request |
@@ -52,10 +53,25 @@ are covered in [Native provider controls](../guides/native-controls.md).
 | `tool_calls` | array | Assistant tool requests returned on a previous turn |
 | `tool_call_id` | string | Connects a `role: "tool"` result to its request |
 | `reasoning_content` | string | Provider-returned reasoning carried into a later turn |
+| `reasoning_signature` | string | Opaque provider signature for the reasoning block; echo it back with `reasoning_content` for lossless round-trip |
+| `redacted_reasoning_content` | string | Opaque data for a redacted reasoning block; echo it back to reconstruct it |
 
 Content blocks may use OpenAI `image_url`, Anthropic `image`, or Gemini
 `inline_data` input forms. See [Images and vision](../guides/images.md).
 
+### Lossless reasoning round-trip
+
+A thinking-capable Anthropic model returns `reasoning_content` **and**
+`reasoning_signature` (streaming emits both incrementally; the signature arrives
+as a `reasoning_signature` delta). Echo the assistant message back verbatim on a
+follow-up request and llmshim reconstructs the provider-native `thinking` block
+(as the first block of the turn) — required for extended-thinking + tool-use
+continuations and for keeping the prompt cache warm. The signature is opaque and
+provider-specific: other providers strip it, so it never leaks in a multi-model
+conversation. Absent a signature, `reasoning_content` is stripped (a thinking
+block without its signature is rejected). Symmetric to the tool-call
+`thought_signature` round-trip.
+
 ## Proxy request
 
 | Field | Type | Class | Engine destination |

{llmshim-0.2.0 → llmshim-0.2.2}/src/providers/anthropic.rs

@@ -161,10 +161,29 @@ fn transform_messages(messages: &[Value]) -> Vec<Value> {
         .map(|msg| {
             let mut out = msg.clone();
 
+            // Capture normalized reasoning fields before sanitizing, so an
+            // assistant turn's thinking block can be reconstructed losslessly
+            // below (symmetric to the tool-call thought_signature round-trip).
+            let role = out.get("role").and_then(|r| r.as_str()).map(str::to_string);
+            let reasoning_content = out
+                .get("reasoning_content")
+                .and_then(|v| v.as_str())
+                .map(str::to_string);
+            let reasoning_signature = out
+                .get("reasoning_signature")
+                .and_then(|v| v.as_str())
+                .map(str::to_string);
+            let redacted_reasoning = out
+                .get("redacted_reasoning_content")
+                .and_then(|v| v.as_str())
+                .map(str::to_string);
+
             // Sanitize cross-provider fields that Anthropic's API rejects.
             // This enables multi-model conversations (e.g., Cursor-style provider switching).
             if let Some(obj) = out.as_object_mut() {
                 obj.remove("reasoning_content"); // our normalized thinking field
+                obj.remove("reasoning_signature"); // reconstructed into a thinking block below
+                obj.remove("redacted_reasoning_content"); // reconstructed into redacted_thinking below
                 obj.remove("annotations"); // OpenAI returns this on every message
                 obj.remove("refusal"); // OpenAI safety refusal field
                 obj.remove("audio"); // OpenAI audio response field
@@ -236,6 +255,38 @@ fn transform_messages(messages: &[Value]) -> Vec<Value> {
                 });
             }
 
+            // Reconstruct thinking block(s) as the FIRST content block(s) of an
+            // assistant turn so extended-thinking + tool-use continuations are
+            // accepted (the API requires thinking before text/tool_use). Only when
+            // we hold the opaque token — a thinking block without its signature is
+            // rejected, so absent a signature we leave it stripped (no regression).
+            if role.as_deref() == Some("assistant") {
+                let mut thinking_blocks: Vec<Value> = Vec::new();
+                if let (Some(text), Some(sig)) = (&reasoning_content, &reasoning_signature) {
+                    thinking_blocks.push(json!({
+                        "type": "thinking",
+                        "thinking": text,
+                        "signature": sig,
+                    }));
+                }
+                if let Some(data) = &redacted_reasoning {
+                    thinking_blocks.push(json!({
+                        "type": "redacted_thinking",
+                        "data": data,
+                    }));
+                }
+                if !thinking_blocks.is_empty() {
+                    match out.get("content").cloned() {
+                        Some(Value::Array(arr)) => thinking_blocks.extend(arr),
+                        Some(Value::String(s)) if !s.is_empty() => {
+                            thinking_blocks.push(json!({"type": "text", "text": s}))
+                        }
+                        _ => {}
+                    }
+                    out["content"] = json!(thinking_blocks);
+                }
+            }
+
             out
         })
         .collect()
@@ -339,6 +390,10 @@ fn transform_response_to_openai(model: &str, resp: &Value) -> Value {
     let mut text_parts: Vec<String> = Vec::new();
     let mut tool_calls: Vec<Value> = Vec::new();
     let mut thinking_content: Option<String> = None;
+    // Opaque signature + redacted data so reasoning can round-trip losslessly
+    // (see transform_messages reconstruction). Symmetric to tool thought_signature.
+    let mut thinking_signature: Option<String> = None;
+    let mut redacted_thinking: Option<String> = None;
 
     for block in &content_blocks {
         match block.get("type").and_then(|t| t.as_str()) {
@@ -351,6 +406,14 @@ fn transform_response_to_openai(model: &str, resp: &Value) -> Value {
                 if let Some(t) = block.get("thinking").and_then(|t| t.as_str()) {
                     thinking_content = Some(t.to_string());
                 }
+                if let Some(s) = block.get("signature").and_then(|s| s.as_str()) {
+                    thinking_signature = Some(s.to_string());
+                }
+            }
+            Some("redacted_thinking") => {
+                if let Some(d) = block.get("data").and_then(|d| d.as_str()) {
+                    redacted_thinking = Some(d.to_string());
+                }
             }
             Some("tool_use") => {
                 tool_calls.push(json!({
@@ -399,6 +462,14 @@ fn transform_response_to_openai(model: &str, resp: &Value) -> Value {
     if let Some(thinking) = thinking_content {
         message["reasoning_content"] = json!(thinking);
     }
+    // Surface the opaque signature + redacted data so the reasoning block can be
+    // echoed back losslessly on a follow-up request (see transform_messages).
+    if let Some(sig) = thinking_signature {
+        message["reasoning_signature"] = json!(sig);
+    }
+    if let Some(data) = redacted_thinking {
+        message["redacted_reasoning_content"] = json!(data);
+    }
 
     json!({
         "id": resp.get("id").cloned().unwrap_or(json!("")),
@@ -532,6 +603,17 @@ impl Provider for Anthropic {
                     .unwrap_or(false);
                 let effort = normalize_unified_effort(effort, pro);
 
+                // Reasoning-summary visibility. Newer models (Sonnet 5, Opus
+                // 4.7/4.8, ...) default `display` to "omitted" — a signed but
+                // empty thinking block with no thinking_delta text. Default to
+                // "summarized" so reasoning text is returned consistently across
+                // model generations; a latency-sensitive caller opts back into
+                // "omitted" via reasoning_summary. Verified live 2026-07-17.
+                let display = match obj.get("reasoning_summary").and_then(|v| v.as_str()) {
+                    Some("none") | Some("omitted") => "omitted",
+                    _ => "summarized",
+                };
+
                 if effort == "none" {
                     if Self::uses_adaptive_thinking(model) {
                         // Adaptive models think by default even with no config;
@@ -541,7 +623,10 @@ impl Provider for Anthropic {
                     }
                     // Pre-4.6/Haiku: thinking is opt-in; omitting the key IS "none".
                 } else if Self::uses_adaptive_thinking(model) {
-                    body_obj.insert("thinking".to_string(), json!({"type": "adaptive"}));
+                    body_obj.insert(
+                        "thinking".to_string(),
+                        json!({"type": "adaptive", "display": display}),
+                    );
                     // Opus/Sonnet 4.6 reject "xhigh" (their tiers: low/medium/high/max);
                     // Opus 4.7/4.8 + Sonnet 5 accept the full low..max range (verified).
                     let anthropic_effort =
@@ -573,7 +658,8 @@ impl Provider for Anthropic {
                         "thinking".to_string(),
                         json!({
                             "type": "enabled",
-                            "budget_tokens": budget
+                            "budget_tokens": budget,
+                            "display": display
                         }),
                     );
                 }
@@ -766,8 +852,25 @@ impl Provider for Anthropic {
                         });
                         Ok(Some(serde_json::to_string(&chunk)?))
                     }
-                    // signature_delta: skip (opaque verification, not useful to consumers)
-                    Some("signature_delta") => Ok(None),
+                    // signature_delta: emit the opaque signature so a streaming
+                    // consumer can reassemble a complete, round-trippable thinking
+                    // block (fed back via reasoning_signature on the next request).
+                    Some("signature_delta") => {
+                        let signature = delta
+                            .get("signature")
+                            .and_then(|s| s.as_str())
+                            .unwrap_or("");
+                        let chunk = json!({
+                            "object": "chat.completion.chunk",
+                            "model": model,
+                            "choices": [{
+                                "index": 0,
+                                "delta": { "reasoning_signature": signature },
+                                "finish_reason": null,
+                            }]
+                        });
+                        Ok(Some(serde_json::to_string(&chunk)?))
+                    }
                     _ => Ok(None),
                 }
             }
@@ -797,6 +900,22 @@ impl Provider for Anthropic {
                         });
                         return Ok(Some(serde_json::to_string(&chunk)?));
                     }
+                    // redacted_thinking arrives whole (no deltas); surface its
+                    // opaque data so it can be echoed back on a later request.
+                    if cb.get("type").and_then(|t| t.as_str()) == Some("redacted_thinking") {
+                        if let Some(data) = cb.get("data").and_then(|d| d.as_str()) {
+                            let chunk = json!({
+                                "object": "chat.completion.chunk",
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": { "redacted_reasoning_content": data },
+                                    "finish_reason": null,
+                                }]
+                            });
+                            return Ok(Some(serde_json::to_string(&chunk)?));
+                        }
+                    }
                 }
                 Ok(None)
             }

{llmshim-0.2.0 → llmshim-0.2.2}/src/providers/openai.rs

@@ -57,6 +57,8 @@ fn sanitize_messages(messages: &[Value]) -> Vec<Value> {
                 let mut out = msg.clone();
                 if let Some(obj) = out.as_object_mut() {
                     obj.remove("reasoning_content");
+                    obj.remove("reasoning_signature"); // opaque Anthropic token — never forward
+                    obj.remove("redacted_reasoning_content"); // opaque Anthropic token — never forward
                     obj.remove("annotations");
                     obj.remove("refusal");
                     obj.remove("tool_calls"); // Handled separately below.
@@ -130,6 +132,8 @@ fn sanitize_messages(messages: &[Value]) -> Vec<Value> {
                 let mut out = msg.clone();
                 if let Some(obj) = out.as_object_mut() {
                     obj.remove("reasoning_content");
+                    obj.remove("reasoning_signature"); // opaque Anthropic token — never forward
+                    obj.remove("redacted_reasoning_content"); // opaque Anthropic token — never forward
                     obj.remove("annotations");
                     obj.remove("refusal");
                 }

{llmshim-0.2.0 → llmshim-0.2.2}/src/providers/xai.rs

@@ -39,6 +39,8 @@ fn sanitize_messages(messages: &[Value]) -> Vec<Value> {
                 let mut out = msg.clone();
                 if let Some(obj) = out.as_object_mut() {
                     obj.remove("reasoning_content");
+                    obj.remove("reasoning_signature"); // opaque Anthropic token — never forward
+                    obj.remove("redacted_reasoning_content"); // opaque Anthropic token — never forward
                     obj.remove("annotations");
                     obj.remove("refusal");
                     obj.remove("tool_calls");
@@ -108,6 +110,8 @@ fn sanitize_messages(messages: &[Value]) -> Vec<Value> {
                 let mut out = msg.clone();
                 if let Some(obj) = out.as_object_mut() {
                     obj.remove("reasoning_content");
+                    obj.remove("reasoning_signature"); // opaque Anthropic token — never forward
+                    obj.remove("redacted_reasoning_content"); // opaque Anthropic token — never forward
                     obj.remove("annotations");
                     obj.remove("refusal");
                 }

{llmshim-0.2.0 → llmshim-0.2.2}/tests/integration_thinking.rs

@@ -330,3 +330,107 @@ async fn three_hop_with_thinking_in_middle() {
         content3
     );
 }
+
+// ============================================================
+// Reasoning round-trip (issue #34) — lossless thinking + tool-use continuation
+// ============================================================
+
+#[tokio::test]
+#[ignore]
+async fn anthropic_reasoning_roundtrip_accepted_live() {
+    if std::env::var("ANTHROPIC_API_KEY").is_err() {
+        return;
+    }
+    let router = router();
+    let model = "anthropic/claude-sonnet-4-6";
+    let tools = json!([{
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get the current weather for a city",
+            "parameters": {
+                "type": "object",
+                "properties": {"city": {"type": "string"}},
+                "required": ["city"]
+            }
+        }
+    }]);
+    let user_turn = json!({"role": "user", "content": "What's the weather in Tokyo? Use the get_weather tool."});
+
+    // Turn 1: thinking on + a tool available → expect thinking + a tool call.
+    let req1 = json!({
+        "model": model,
+        "messages": [user_turn],
+        "max_tokens": 4000,
+        "reasoning_effort": "high",
+        "tools": tools,
+    });
+    let resp1 = llmshim::completion(&router, &req1).await.unwrap();
+    let msg1 = &resp1["choices"][0]["message"];
+
+    let tool_calls = msg1
+        .get("tool_calls")
+        .and_then(|t| t.as_array())
+        .filter(|a| !a.is_empty());
+    assert!(tool_calls.is_some(), "expected a tool call, got: {resp1}");
+    assert!(
+        msg1.get("reasoning_signature").is_some(),
+        "expected reasoning_signature to be surfaced, got: {msg1}"
+    );
+    let call_id = tool_calls.unwrap()[0]["id"].as_str().unwrap().to_string();
+
+    // Turn 2: echo the assistant message VERBATIM (reasoning_content +
+    // reasoning_signature + tool_calls) and add the tool result. The shim must
+    // reconstruct a valid thinking block first — the API must accept it (200).
+    let req2 = json!({
+        "model": model,
+        "messages": [
+            user_turn,
+            msg1.clone(),
+            {"role": "tool", "tool_call_id": call_id, "content": "72F and sunny"}
+        ],
+        "max_tokens": 4000,
+        "reasoning_effort": "high",
+        "tools": tools,
+    });
+    let resp2 = llmshim::completion(&router, &req2)
+        .await
+        .expect("reconstructed thinking block must be accepted by the API");
+    assert_eq!(resp2["object"], "chat.completion");
+    let content = resp2["choices"][0]["message"]["content"]
+        .as_str()
+        .unwrap_or("");
+    assert!(!content.is_empty(), "expected a final answer, got: {resp2}");
+    println!("Round-trip accepted. Final answer: {content}");
+}
+
+#[tokio::test]
+#[ignore]
+async fn anthropic_sonnet5_reasoning_summary_default_returns_text_live() {
+    // Issue #37: sonnet-5 defaults display to "omitted" (empty thinking text).
+    // With the fix, reasoning_effort defaults display to "summarized" so real
+    // reasoning text comes back.
+    if std::env::var("ANTHROPIC_API_KEY").is_err() {
+        return;
+    }
+    let router = router();
+    // A prompt that reliably engages adaptive thinking (trivial prompts may be
+    // answered directly even at high effort — "adaptive" means the model decides).
+    let prompt = "Prove or disprove: for every positive integer n, the value \
+        n^2 + n + 41 is prime. Give rigorous reasoning.";
+    let req = json!({
+        "model": "anthropic/claude-sonnet-5",
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 4000,
+        "reasoning_effort": "high",
+    });
+    let resp = llmshim::completion(&router, &req).await.unwrap();
+    let reasoning = resp["choices"][0]["message"]["reasoning_content"]
+        .as_str()
+        .unwrap_or("");
+    assert!(
+        !reasoning.is_empty(),
+        "expected reasoning text by default (display=summarized), got empty. resp: {resp}"
+    );
+    println!("sonnet-5 reasoning text chars: {}", reasoning.len());
+}

{llmshim-0.2.0 → llmshim-0.2.2}/tests/unit_anthropic.rs

@@ -1131,7 +1131,9 @@ fn stream_thinking_delta() {
 }
 
 #[test]
-fn stream_signature_delta_skipped() {
+fn stream_signature_delta_emits_signature() {
+    // Issue #34: the signature is now surfaced (was previously dropped) so a
+    // streaming consumer can reassemble a round-trippable thinking block.
     let p = provider();
     let chunk = json!({
         "type": "content_block_delta",
@@ -1139,8 +1141,13 @@ fn stream_signature_delta_skipped() {
     });
     let result = p
         .transform_stream_chunk("x", &serde_json::to_string(&chunk).unwrap())
+        .unwrap()
         .unwrap();
-    assert!(result.is_none(), "signature_delta should be skipped");
+    let parsed: Value = serde_json::from_str(&result).unwrap();
+    assert_eq!(
+        parsed["choices"][0]["delta"]["reasoning_signature"],
+        "EqoBCkgIAxgC..."
+    );
 }
 
 // ============================================================
@@ -1576,3 +1583,264 @@ fn top_level_thinking_passthrough_strips_temperature() {
     assert_eq!(result.body["thinking"]["type"], "adaptive");
     assert!(result.body.get("temperature").is_none());
 }
+
+// ============================================================
+// Reasoning round-trip (issue #34): signature + redacted passthrough
+// ============================================================
+
+#[test]
+fn response_surfaces_reasoning_signature() {
+    let p = provider();
+    let resp = json!({
+        "id": "msg_r",
+        "content": [
+            {"type": "thinking", "thinking": "Let me think...", "signature": "sig-abc123"},
+            {"type": "text", "text": "The answer is 42."}
+        ],
+        "stop_reason": "end_turn",
+        "usage": {"input_tokens": 5, "output_tokens": 3}
+    });
+    let result = p.transform_response("claude-opus-4-8", resp).unwrap();
+    let msg = &result["choices"][0]["message"];
+    assert_eq!(msg["reasoning_content"], "Let me think...");
+    assert_eq!(msg["reasoning_signature"], "sig-abc123");
+    assert_eq!(msg["content"], "The answer is 42.");
+}
+
+#[test]
+fn response_surfaces_redacted_reasoning() {
+    let p = provider();
+    let resp = json!({
+        "id": "msg_r",
+        "content": [
+            {"type": "redacted_thinking", "data": "encrypted-blob-xyz"},
+            {"type": "text", "text": "Done."}
+        ],
+        "stop_reason": "end_turn",
+        "usage": {"input_tokens": 5, "output_tokens": 3}
+    });
+    let result = p.transform_response("claude-opus-4-8", resp).unwrap();
+    assert_eq!(
+        result["choices"][0]["message"]["redacted_reasoning_content"],
+        "encrypted-blob-xyz"
+    );
+}
+
+#[test]
+fn request_reconstructs_thinking_block_first_with_tool_calls() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-opus-4-8",
+        "messages": [
+            {"role": "user", "content": "weather?"},
+            {
+                "role": "assistant",
+                "content": "",
+                "reasoning_content": "I should call the tool.",
+                "reasoning_signature": "sig-xyz",
+                "tool_calls": [{
+                    "id": "call_1",
+                    "type": "function",
+                    "function": {"name": "get_weather", "arguments": "{\"city\":\"Tokyo\"}"}
+                }]
+            }
+        ]
+    });
+    let result = p.transform_request("claude-opus-4-8", &req).unwrap();
+    let content = &result.body["messages"][1]["content"];
+    // Thinking block must be FIRST (with signature), before the tool_use block.
+    assert_eq!(content[0]["type"], "thinking");
+    assert_eq!(content[0]["thinking"], "I should call the tool.");
+    assert_eq!(content[0]["signature"], "sig-xyz");
+    assert_eq!(content[1]["type"], "tool_use");
+    // Normalized fields must not leak raw on the message.
+    assert!(result.body["messages"][1]
+        .get("reasoning_content")
+        .is_none());
+    assert!(result.body["messages"][1]
+        .get("reasoning_signature")
+        .is_none());
+}
+
+#[test]
+fn request_reconstructs_thinking_block_plain_text() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-opus-4-8",
+        "messages": [{
+            "role": "assistant",
+            "content": "Final answer.",
+            "reasoning_content": "thinking...",
+            "reasoning_signature": "sig-1"
+        }]
+    });
+    let result = p.transform_request("claude-opus-4-8", &req).unwrap();
+    let content = &result.body["messages"][0]["content"];
+    assert_eq!(content[0]["type"], "thinking");
+    assert_eq!(content[0]["signature"], "sig-1");
+    assert_eq!(content[1]["type"], "text");
+    assert_eq!(content[1]["text"], "Final answer.");
+}
+
+#[test]
+fn request_reconstructs_redacted_thinking() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-opus-4-8",
+        "messages": [{
+            "role": "assistant",
+            "content": "ok",
+            "redacted_reasoning_content": "blob-1"
+        }]
+    });
+    let result = p.transform_request("claude-opus-4-8", &req).unwrap();
+    let content = &result.body["messages"][0]["content"];
+    assert_eq!(content[0]["type"], "redacted_thinking");
+    assert_eq!(content[0]["data"], "blob-1");
+}
+
+#[test]
+fn request_no_signature_strips_reasoning() {
+    // Without a signature a thinking block would 400, so we strip (no regression).
+    let p = provider();
+    let req = json!({
+        "model": "claude-opus-4-8",
+        "messages": [{
+            "role": "assistant",
+            "content": "hi",
+            "reasoning_content": "orphan thinking, no signature"
+        }]
+    });
+    let result = p.transform_request("claude-opus-4-8", &req).unwrap();
+    let msg = &result.body["messages"][0];
+    assert!(msg.get("reasoning_content").is_none());
+    assert_eq!(msg["content"], "hi"); // stays a plain string, no thinking block
+}
+
+#[test]
+fn stream_signature_delta_emits_reasoning_signature() {
+    let p = provider();
+    let chunk = json!({
+        "type": "content_block_delta",
+        "delta": {"type": "signature_delta", "signature": "sig-stream-1"}
+    });
+    let result = p
+        .transform_stream_chunk("x", &serde_json::to_string(&chunk).unwrap())
+        .unwrap()
+        .unwrap();
+    let parsed: Value = serde_json::from_str(&result).unwrap();
+    assert_eq!(
+        parsed["choices"][0]["delta"]["reasoning_signature"],
+        "sig-stream-1"
+    );
+}
+
+#[test]
+fn stream_redacted_thinking_block_start_emits() {
+    let p = provider();
+    let chunk = json!({
+        "type": "content_block_start",
+        "index": 0,
+        "content_block": {"type": "redacted_thinking", "data": "blob-stream"}
+    });
+    let result = p
+        .transform_stream_chunk("x", &serde_json::to_string(&chunk).unwrap())
+        .unwrap()
+        .unwrap();
+    let parsed: Value = serde_json::from_str(&result).unwrap();
+    assert_eq!(
+        parsed["choices"][0]["delta"]["redacted_reasoning_content"],
+        "blob-stream"
+    );
+}
+
+// ============================================================
+// Reasoning summary visibility (issue #37): thinking.display
+// ============================================================
+
+#[test]
+fn adaptive_thinking_defaults_display_summarized() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-sonnet-5",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "high",
+    });
+    let result = p.transform_request("claude-sonnet-5", &req).unwrap();
+    assert_eq!(result.body["thinking"]["type"], "adaptive");
+    assert_eq!(result.body["thinking"]["display"], "summarized");
+    assert_eq!(result.body["output_config"]["effort"], "high");
+}
+
+#[test]
+fn adaptive_thinking_reasoning_summary_none_omits() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-sonnet-5",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "high",
+        "reasoning_summary": "none",
+    });
+    let result = p.transform_request("claude-sonnet-5", &req).unwrap();
+    assert_eq!(result.body["thinking"]["display"], "omitted");
+    // The unified control must not leak into the API body.
+    assert!(result.body.get("reasoning_summary").is_none());
+}
+
+#[test]
+fn adaptive_thinking_reasoning_summary_auto_summarizes() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-opus-4-8",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "medium",
+        "reasoning_summary": "auto",
+    });
+    let result = p.transform_request("claude-opus-4-8", &req).unwrap();
+    assert_eq!(result.body["thinking"]["display"], "summarized");
+}
+
+#[test]
+fn enabled_thinking_forwards_display() {
+    // Pre-4.6 / Haiku use the enabled-budget path; display is valid there too.
+    let p = provider();
+    let req = json!({
+        "model": "claude-haiku-4-5-20251001",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "high",
+    });
+    let result = p
+        .transform_request("claude-haiku-4-5-20251001", &req)
+        .unwrap();
+    assert_eq!(result.body["thinking"]["type"], "enabled");
+    assert_eq!(result.body["thinking"]["display"], "summarized");
+    assert!(result.body["thinking"]["budget_tokens"].as_u64().unwrap() >= 1024);
+}
+
+#[test]
+fn reasoning_effort_none_stays_disabled_without_display() {
+    let p = provider();
+    let req = json!({
+        "model": "claude-sonnet-5",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "none",
+    });
+    let result = p.transform_request("claude-sonnet-5", &req).unwrap();
+    assert_eq!(result.body["thinking"]["type"], "disabled");
+    assert!(result.body["thinking"].get("display").is_none());
+}
+
+#[test]
+fn passthrough_thinking_display_untouched() {
+    // A caller-supplied thinking block wins; the effort translation (and its
+    // default display) is bypassed by the has_thinking gate.
+    let p = provider();
+    let req = json!({
+        "model": "claude-sonnet-5",
+        "messages": [{"role": "user", "content": "hi"}],
+        "reasoning_effort": "high",
+        "thinking": {"type": "adaptive", "display": "omitted"},
+    });
+    let result = p.transform_request("claude-sonnet-5", &req).unwrap();
+    assert_eq!(result.body["thinking"]["display"], "omitted");
+}

{llmshim-0.2.0 → llmshim-0.2.2}/tests/unit_gemini.rs

@@ -1507,3 +1507,25 @@ fn mode_pro_bumps_thinking_level_and_none_wins() {
         "minimal"
     );
 }
+
+#[test]
+fn request_strips_foreign_reasoning_signature() {
+    // Issue #34: Gemini rebuilds messages into contents/parts, so an opaque
+    // Anthropic reasoning signature is naturally dropped — verify it never leaks.
+    let p = provider();
+    let req = json!({
+        "model": "gemini-3.5-flash",
+        "messages": [{
+            "role": "assistant",
+            "content": "hi",
+            "reasoning_content": "x",
+            "reasoning_signature": "anthropic-sig-should-not-leak",
+            "redacted_reasoning_content": "redacted-should-not-leak"
+        }]
+    });
+    let result = p.transform_request("gemini-3.5-flash", &req).unwrap();
+    let body = serde_json::to_string(&result.body).unwrap();
+    assert!(!body.contains("anthropic-sig-should-not-leak"));
+    assert!(!body.contains("redacted-should-not-leak"));
+    assert!(!body.contains("reasoning_signature"));
+}

{llmshim-0.2.0 → llmshim-0.2.2}/tests/unit_openai.rs

@@ -891,3 +891,25 @@ fn mode_pro_without_effort() {
     assert_eq!(r.body["reasoning"]["effort"], "high");
     assert!(r.body["reasoning"].get("mode").is_none());
 }
+
+#[test]
+fn request_strips_foreign_reasoning_signature() {
+    // Issue #34: an opaque Anthropic reasoning signature must never leak into an
+    // OpenAI request in a multi-model conversation.
+    let p = provider();
+    let req = json!({
+        "model": "gpt-5.4",
+        "messages": [{
+            "role": "assistant",
+            "content": "hi",
+            "reasoning_content": "x",
+            "reasoning_signature": "anthropic-sig-should-not-leak",
+            "redacted_reasoning_content": "redacted-should-not-leak"
+        }]
+    });
+    let result = p.transform_request("gpt-5.4", &req).unwrap();
+    let body = serde_json::to_string(&result.body).unwrap();
+    assert!(!body.contains("anthropic-sig-should-not-leak"));
+    assert!(!body.contains("redacted-should-not-leak"));
+    assert!(!body.contains("reasoning_signature"));
+}

{llmshim-0.2.0 → llmshim-0.2.2}/tests/unit_xai.rs

@@ -736,3 +736,25 @@ fn grok_4_5_effort_range() {
         assert_eq!(r.body["reasoning"]["effort"], expected, "effort {effort}");
     }
 }
+
+#[test]
+fn request_strips_foreign_reasoning_signature() {
+    // Issue #34: an opaque Anthropic reasoning signature must never leak into an
+    // xAI request in a multi-model conversation.
+    let p = provider();
+    let req = json!({
+        "model": "grok-4.3",
+        "messages": [{
+            "role": "assistant",
+            "content": "hi",
+            "reasoning_content": "x",
+            "reasoning_signature": "anthropic-sig-should-not-leak",
+            "redacted_reasoning_content": "redacted-should-not-leak"
+        }]
+    });
+    let result = p.transform_request("grok-4.3", &req).unwrap();
+    let body = serde_json::to_string(&result.body).unwrap();
+    assert!(!body.contains("anthropic-sig-should-not-leak"));
+    assert!(!body.contains("redacted-should-not-leak"));
+    assert!(!body.contains("reasoning_signature"));
+}