Merge branch 'dev/goal0610' into dev/websearch0610

# Conflicts:
#	crates/provider/src/anthropic/messages.rs
#	crates/provider/src/openai/chat_completions.rs
#	crates/provider/src/openai/responses.rs

Author: wangtsiao

crates/provider/src/anthropic/messages.rs

@@ -35,6 +35,7 @@ use crate::ProviderAdapter;
 use crate::ProviderCapabilities;
 use crate::ProviderHttpOptions;
 use crate::hosted_tools::append_anthropic_hosted_tools;
+use crate::http::invalid_status_error;
 use crate::merge_extra_body;
 
 /// <https://platform.claude.com/docs/en/api/messages>
@@ -121,6 +122,8 @@ struct AnthropicInputMessage {
 enum AnthropicInputContentBlock {
     #[serde(rename = "text")]
     Text { text: String },
+    #[serde(rename = "thinking")]
+    Thinking { thinking: String },
     #[serde(rename = "tool_use")]
     ToolUse {
         id: String,
@@ -271,9 +274,22 @@ impl ModelProviderSDK for AnthropicProvider {
             .request_builder(&body)
             .send()
             .await
-            .context("failed to send anthropic request")?
-            .error_for_status()
-            .context("anthropic request failed")?;
+            .context("failed to send anthropic request")?;
+        let response = match response.error_for_status_ref() {
+            Ok(_) => response,
+            Err(_) => {
+                let status = response.status();
+                return Err(invalid_status_error(
+                    "anthropic",
+                    &request.model,
+                    "request",
+                    status,
+                    response,
+                    &body,
+                )
+                .await);
+            }
+        };
 
         let value: Value = response
             .json()
@@ -311,9 +327,24 @@ impl ModelProviderSDK for AnthropicProvider {
 
             futures::pin_mut!(event_source);
             while let Some(event) = event_source.next().await {
-                let event = event.map_err(|error| {
-                    anyhow::anyhow!("anthropic stream error for model {}: {error}", request.model)
-                })?;
+                let event = match event {
+                    Ok(event) => event,
+                    Err(reqwest_eventsource::Error::InvalidStatusCode(status, response)) => {
+                        Err(invalid_status_error(
+                            "anthropic",
+                            &request.model,
+                            "stream",
+                            status,
+                            response,
+                            &body,
+                        )
+                        .await)?
+                    }
+                    Err(error) => Err(anyhow::anyhow!(
+                        "anthropic stream error for model {}: {error}",
+                        request.model
+                    ))?,
+                };
 
                 match event {
                     Event::Open => {}
@@ -944,9 +975,9 @@ fn build_message(message: &RequestMessage) -> AnthropicInputMessage {
 fn build_content_block(block: &RequestContent) -> AnthropicInputContentBlock {
     match block {
         RequestContent::Text { text } => AnthropicInputContentBlock::Text { text: text.clone() },
-        RequestContent::Reasoning { text } => {
-            AnthropicInputContentBlock::Text { text: text.clone() }
-        }
+        RequestContent::Reasoning { text } => AnthropicInputContentBlock::Thinking {
+            thinking: text.clone(),
+        },
         RequestContent::ToolUse { id, name, input } => AnthropicInputContentBlock::ToolUse {
             id: id.clone(),
             name: name.clone(),
@@ -1186,6 +1217,58 @@ mod tests {
         assert_eq!(body["tools"][0]["name"], json!("get_weather"));
     }
 
+    #[test]
+    fn build_request_serializes_reasoning_as_thinking_block() {
+        let request = ModelRequest {
+            model: "deepseek-v4-flash".to_string(),
+            system: None,
+            messages: vec![RequestMessage {
+                role: "assistant".to_string(),
+                content: vec![
+                    RequestContent::Reasoning {
+                        text: "Need to inspect the file first.".to_string(),
+                    },
+                    RequestContent::Text {
+                        text: "I'll read the README.".to_string(),
+                    },
+                    RequestContent::ToolUse {
+                        id: "toolu_123".to_string(),
+                        name: "read".to_string(),
+                        input: json!({"path": "README.md"}),
+                    },
+                ],
+            }],
+            max_tokens: 1024,
+            tools: None,
+            sampling: SamplingControls::default(),
+            thinking: Some("enabled".to_string()),
+            reasoning_effort: None,
+            extra_body: None,
+        };
+
+        let body = build_request(&request, true);
+
+        assert_eq!(
+            body["messages"][0]["content"],
+            json!([
+                {
+                    "type": "thinking",
+                    "thinking": "Need to inspect the file first."
+                },
+                {
+                    "type": "text",
+                    "text": "I'll read the README."
+                },
+                {
+                    "type": "tool_use",
+                    "id": "toolu_123",
+                    "name": "read",
+                    "input": { "path": "README.md" }
+                }
+            ])
+        );
+    }
+
     #[test]
     fn parse_response_extracts_text_tool_use_reasoning_and_usage() {
         let response = parse_response(json!({

crates/provider/src/http.rs

@@ -4,10 +4,13 @@ use anyhow::Context;
 use anyhow::Result;
 use reqwest::Client;
 use reqwest::RequestBuilder;
+use reqwest::Response;
+use reqwest::StatusCode;
 use reqwest::header::HeaderMap;
 use reqwest::header::HeaderName;
 use reqwest::header::HeaderValue;
 use serde_json::Value;
+use tracing::warn;
 
 /// HTTP options shared by model-provider adapters.
 #[derive(Clone, Debug, Default)]
@@ -54,6 +57,32 @@ impl ProviderHttpOptions {
     }
 }
 
+pub(crate) async fn invalid_status_error(
+    provider: &'static str,
+    model: &str,
+    operation: &str,
+    status: StatusCode,
+    response: Response,
+    request_body: &Value,
+) -> anyhow::Error {
+    let response_body = response
+        .text()
+        .await
+        .unwrap_or_else(|error| format!("<failed to read response body: {error}>"));
+    warn!(
+        provider,
+        model,
+        operation,
+        status = %status,
+        http_body = %request_body,
+        response_body = %response_body,
+        "provider request failed"
+    );
+    anyhow::anyhow!(
+        "{provider} {operation} error for model {model}: Invalid status code: {status}; response body: {response_body}"
+    )
+}
+
 fn parse_custom_headers(headers: Option<String>) -> Result<HeaderMap> {
     let Some(headers) = headers.and_then(|value| non_empty_string(&value)) else {
         return Ok(HeaderMap::new());

crates/provider/src/openai/chat_completions.rs

@@ -27,7 +27,6 @@ use devo_protocol::Usage;
 use super::capabilities::OpenAIReasoningMode;
 use super::capabilities::OpenAITransport;
 use super::capabilities::resolve_request_profile;
-use super::shared::invalid_status_error;
 use super::shared::reasoning_value;
 use super::shared::request_role;
 use super::shared::tool_definitions;
@@ -36,6 +35,7 @@ use crate::ProviderAdapter;
 use crate::ProviderCapabilities;
 use crate::ProviderHttpOptions;
 use crate::hosted_tools::apply_openai_chat_completions_hosted_tools;
+use crate::http::invalid_status_error;
 use crate::merge_extra_body;
 use crate::text_normalization::split_tagged_text;
 

crates/provider/src/openai/chat_completions/stream.rs

@@ -12,14 +12,14 @@ use reqwest_eventsource::{Event, EventSource};
 use serde::Deserialize;
 use serde_json::Value;
 
-use super::super::shared::invalid_status_error;
 use super::{
     OpenAIChatCompletionChoice, OpenAIChatCompletionCustomToolCall,
     OpenAIChatCompletionFunctionCall, OpenAIChatCompletionMessage,
     OpenAIChatCompletionMessageToolCall, OpenAIChoiceLogprobs, OpenAICompletionUsage,
     OpenAIProvider, build_provider_specific_response_payload, build_request, parse_finish_reason,
     parse_tool_use,
 };
+use crate::http::invalid_status_error;
 use crate::text_normalization::{TaggedTextFragment, TaggedTextParser};
 
 /// <https://developers.openai.com/api/reference/resources/chat/subresources/completions/streaming-events>

crates/provider/src/openai/responses.rs

@@ -14,13 +14,14 @@ use serde_json::{Value, json};
 use tracing::debug;
 
 use crate::hosted_tools::append_openai_responses_hosted_tools;
+use crate::http::invalid_status_error;
 use crate::text_normalization::{TaggedTextFragment, TaggedTextParser, split_tagged_text};
 use crate::{ModelProviderSDK, ProviderHttpOptions, merge_extra_body};
 
 use super::capabilities::{OpenAITransport, resolve_request_profile};
 use super::{
     OpenAIRole,
-    shared::{invalid_status_error, request_role, tool_definitions},
+    shared::{request_role, tool_definitions},
 };
 
 /// OpenAI Responses API provider.

crates/provider/src/openai/shared.rs

@@ -1,7 +1,5 @@
 use devo_protocol::RequestRole;
 use devo_protocol::ToolDefinition;
-use reqwest::Response;
-use reqwest::StatusCode;
 use serde_json::Value;
 use serde_json::json;
 use tracing::warn;
@@ -97,29 +95,3 @@ pub(crate) fn tool_definitions(tools: &[ToolDefinition]) -> Value {
             .collect(),
     )
 }
-
-pub(crate) async fn invalid_status_error(
-    provider: &'static str,
-    model: &str,
-    operation: &str,
-    status: StatusCode,
-    response: Response,
-    request_body: &Value,
-) -> anyhow::Error {
-    let response_body = response
-        .text()
-        .await
-        .unwrap_or_else(|error| format!("<failed to read response body: {error}>"));
-    warn!(
-        provider,
-        model,
-        operation,
-        status = %status,
-        http_body = %request_body,
-        response_body = %response_body,
-        "provider request failed"
-    );
-    anyhow::anyhow!(
-        "{provider} {operation} error for model {model}: Invalid status code: {status}; response body: {response_body}"
-    )
-}