fix(context): prevent duplicate reasoning block (#2782)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Tushar Mathur <tusharmath@gmail.com>

Author: 3 people

crates/forge_domain/src/context.rs

@@ -567,21 +567,19 @@ impl Context {
         tool_records: Vec<(ToolCallFull, ToolResult)>,
         phase: Option<MessagePhase>,
     ) -> Self {
-        // Convert flat reasoning string to reasoning_details if present
-        let merged_reasoning_details = if let Some(reasoning_text) = reasoning {
-            let reasoning_entry = ReasoningFull {
+        // Convert flat reasoning string to reasoning_details only when no structured
+        // reasoning_details are present. When reasoning_details already exists it
+        // already contains the text (with its cryptographic signature), so adding
+        // another entry from the raw `reasoning` string would produce a duplicate
+        // thinking block with a null signature, which Anthropic rejects.
+        let merged_reasoning_details = match (reasoning, reasoning_details) {
+            (_, Some(details)) => Some(details),
+            (Some(reasoning_text), None) => Some(vec![ReasoningFull {
                 text: Some(reasoning_text),
                 type_of: Some("reasoning.text".to_string()),
                 ..Default::default()
-            };
-            if let Some(mut existing_details) = reasoning_details {
-                existing_details.push(reasoning_entry);
-                Some(existing_details)
-            } else {
-                Some(vec![reasoning_entry])
-            }
-        } else {
-            reasoning_details
+            }]),
+            (None, None) => None,
         };
 
         // Adding tool calls
@@ -1641,4 +1639,59 @@ mod tests {
 
         assert_eq!(actual, expected);
     }
+
+    /// Regression test: when both `reasoning` (raw text) and
+    /// `reasoning_details` (structured, with a cryptographic signature) are
+    /// present, `append_message` must NOT create a duplicate thinking block
+    /// with a null signature.
+    ///
+    /// The Anthropic API rejects messages where any thinking block carries a
+    /// null or missing signature, so the stored `reasoning_details` must
+    /// contain exactly the structured entries that were passed in — no
+    /// extras.
+    #[test]
+    fn test_append_message_does_not_duplicate_reasoning_when_details_present() {
+        // Fixture: a structured reasoning detail with a valid signature, as would
+        // arrive after aggregating an Anthropic streaming response.
+        let fixture_details = vec![ReasoningFull {
+            text: Some("Let me think about this.".to_string()),
+            signature: Some("EpwFvalidSignatureABC123".to_string()),
+            type_of: Some("reasoning.text".to_string()),
+            format: Some("anthropic-claude-v1".to_string()),
+            index: Some(0),
+            ..Default::default()
+        }];
+
+        // Both reasoning (raw string) and reasoning_details (structured) are provided,
+        // mirroring what orch.rs passes after collecting a streamed Anthropic response.
+        let fixture = Context::default().add_message(ContextMessage::user("Hello", None));
+        let actual = fixture.append_message(
+            "Answer",
+            None,
+            Some("Let me think about this.".to_string()), // raw reasoning string
+            Some(fixture_details.clone()),                // structured reasoning_details
+            Usage::default(),
+            vec![],
+            None,
+        );
+
+        // Extract the stored reasoning_details from the assistant message.
+        let stored = actual
+            .messages
+            .iter()
+            .find_map(|entry| {
+                if let ContextMessage::Text(msg) = &**entry
+                    && msg.role == Role::Assistant
+                {
+                    return msg.reasoning_details.as_ref();
+                }
+                None
+            })
+            .expect("Assistant message should have reasoning_details");
+
+        // Expected: exactly the one structured entry that was passed in.
+        // No duplicate null-signature entry should have been appended.
+        let expected = fixture_details;
+        assert_eq!(stored, &expected);
+    }
 }