Merge pull request #165 from jhult/fix/deepseek-reasoning-content

fix(deepseek): preserve reasoning_content for V4 thinking-mode multi-turn

Author: Kuberwastaken

src-rust/crates/api/src/providers/openai_compat.rs

@@ -64,6 +64,12 @@ pub struct ProviderQuirks {
     /// reasoning output.  Example: `Some("reasoning_content")` for DeepSeek.
     pub reasoning_field: Option<String>,
 
+    /// Whether this provider requires reasoning_content to be echoed back on
+    /// subsequent turns in multi-turn conversations.  DeepSeek V4 is currently
+    /// the only provider with this requirement; most providers ignore this field.
+    /// When false, reasoning is not included in outbound messages to save tokens.
+    pub requires_reasoning_roundtrip: bool,
+
     /// Hard cap on `max_tokens` sent to this provider.  When the request
     /// carries a higher value it is silently clamped down to this limit.
     /// Use this for providers whose models have a lower output ceiling than
@@ -241,21 +247,23 @@ impl OpenAiCompatProvider {
             Self::apply_fix_tool_user_sequence(&mut messages);
         }
 
-        // For providers with a reasoning field (e.g. DeepSeek's
-        // "reasoning_content"), inject reasoning text back into assistant
-        // messages that contain tool calls. Non-tool-call turns omit the
-        // field to save tokens.
-        if let Some(ref field) = self.quirks.reasoning_field {
-            Self::inject_reasoning_for_tool_turns(
-                &mut messages,
-                &request.messages,
-                field,
-            );
+        // For providers that require reasoning_content in multi-turn conversations
+        // (e.g. DeepSeek V4), inject reasoning text back into assistant messages
+        // that contain tool calls. Non-tool-call turns omit the field to save tokens.
+        // Only providers with requires_reasoning_roundtrip=true need this.
+        if self.quirks.requires_reasoning_roundtrip {
+            if let Some(ref field) = self.quirks.reasoning_field {
+                Self::inject_reasoning_for_tool_turns(
+                    &mut messages,
+                    &request.messages,
+                    field,
+                );
+            }
         }
 
-        // Some providers (DeepSeek, Ollama) reject `content: null` on
-        // assistant messages — replace with an empty string.
-        if self.quirks.reasoning_field.is_some() || self.quirks.no_api_key_required {
+        // Some providers (DeepSeek when reasoning_roundtrip enabled, Ollama) reject
+        // `content: null` on assistant messages — replace with an empty string.
+        if self.quirks.requires_reasoning_roundtrip || self.quirks.no_api_key_required {
             Self::ensure_content_not_null(&mut messages);
         }
 
@@ -832,6 +840,12 @@ impl LlmProvider for OpenAiCompatProvider {
             let mut message_started = false;
             let mut message_id = String::from("unknown");
             let mut model_name = String::new();
+            // Dedicated index for the Thinking content block emitted when a
+            // provider streams a `reasoning_content` field (DeepSeek V4, etc.).
+            // Chosen to avoid colliding with text (index 0) or tool calls
+            // (1 + tc_index).
+            const THINKING_BLOCK_INDEX: usize = usize::MAX - 100;
+            let mut thinking_open = false;
             let mut tool_call_buffers: std::collections::HashMap<
                 usize,
                 (String, String, String),
@@ -961,8 +975,28 @@ impl LlmProvider for OpenAiCompatProvider {
                         for field in &fields_to_check {
                             if let Some(reasoning) = delta.get(*field).and_then(|v| v.as_str()) {
                                 if !reasoning.is_empty() {
+                                    // Open a dedicated Thinking block on first
+                                    // reasoning delta so the accumulator has a
+                                    // partial to append into (see
+                                    // StreamAccumulator::on_event).  Without
+                                    // this start event the reasoning deltas
+                                    // would be dropped and the completed
+                                    // assistant message would not carry any
+                                    // ContentBlock::Thinking — which is what
+                                    // DeepSeek V4 thinking mode requires the
+                                    // client to echo back on subsequent turns.
+                                    if !thinking_open {
+                                        yield Ok(StreamEvent::ContentBlockStart {
+                                            index: THINKING_BLOCK_INDEX,
+                                            content_block: ContentBlock::Thinking {
+                                                thinking: String::new(),
+                                                signature: String::new(),
+                                            },
+                                        });
+                                        thinking_open = true;
+                                    }
                                     yield Ok(StreamEvent::ReasoningDelta {
-                                        index: 0,
+                                        index: THINKING_BLOCK_INDEX,
                                         reasoning: reasoning.to_string(),
                                     });
                                     break;
@@ -974,6 +1008,15 @@ impl LlmProvider for OpenAiCompatProvider {
                     // Text content delta
                     if let Some(content) = delta.get("content").and_then(|c| c.as_str()) {
                         if !content.is_empty() {
+                            // Close any open thinking block before visible text
+                            // starts streaming, so the blocks land in order in
+                            // the final message: [Thinking, Text, ToolUse...].
+                            if thinking_open {
+                                yield Ok(StreamEvent::ContentBlockStop {
+                                    index: THINKING_BLOCK_INDEX,
+                                });
+                                thinking_open = false;
+                            }
                             yield Ok(StreamEvent::TextDelta {
                                 index: 0,
                                 text: content.to_string(),
@@ -985,6 +1028,14 @@ impl LlmProvider for OpenAiCompatProvider {
                     if let Some(tool_calls) =
                         delta.get("tool_calls").and_then(|t| t.as_array())
                     {
+                        // Close any open thinking block before tool calls
+                        // start (same ordering guarantee as for text above).
+                        if thinking_open {
+                            yield Ok(StreamEvent::ContentBlockStop {
+                                index: THINKING_BLOCK_INDEX,
+                            });
+                            thinking_open = false;
+                        }
                         for tc in tool_calls {
                             let tc_index = tc
                                 .get("index")
@@ -1039,6 +1090,14 @@ impl LlmProvider for OpenAiCompatProvider {
                         choice.get("finish_reason").and_then(|v| v.as_str())
                     {
                         if !finish_reason.is_empty() && finish_reason != "null" {
+                            // Flush any still-open thinking block first so it
+                            // is finalized into the assistant message.
+                            if thinking_open {
+                                yield Ok(StreamEvent::ContentBlockStop {
+                                    index: THINKING_BLOCK_INDEX,
+                                });
+                                thinking_open = false;
+                            }
                             yield Ok(StreamEvent::ContentBlockStop { index: 0 });
                             let mut tc_indices: Vec<usize> =
                                 tool_call_buffers.keys().cloned().collect();

src-rust/crates/api/src/providers/openai_compat_providers.rs

@@ -134,6 +134,8 @@ pub fn custom_openai() -> OpenAiCompatProvider {
 }
 
 /// DeepSeek V4 — supports reasoning output via `reasoning_content` field.
+/// V4 models require reasoning_content to be echoed back on subsequent turns
+/// in multi-turn conversations with tool calls.
 /// Reads `DEEPSEEK_API_KEY`.
 pub fn deepseek() -> OpenAiCompatProvider {
     let key = std::env::var("DEEPSEEK_API_KEY").unwrap_or_default();
@@ -145,6 +147,7 @@ pub fn deepseek() -> OpenAiCompatProvider {
     .with_api_key(key)
     .with_quirks(ProviderQuirks {
         reasoning_field: Some("reasoning_content".to_string()),
+        requires_reasoning_roundtrip: true,
         overflow_patterns: vec!["maximum context length is".to_string()],
         include_usage_in_stream: true,
         max_tokens_cap: None,