Merge pull request #238 from editor-code-assistant/fix-deepseek-reasoner-flow

Fix deepseek reasoner flow

Author: ericdallo

integration-test/integration/chat/github_copilot_test.clj

@@ -168,8 +168,7 @@
         (match-content chat-id "system" {:type "progress" :state "finished"})
         (is (match?
              {:input [{:role "user" :content [{:type "input_text" :text "hello!"}]}
-                      {:role "assistant" :content [{:type "output_text" :text "<think>I should say hello</think>"}]}
-                      {:role "assistant" :content [{:type "output_text" :text "hello there!"}]}
+                      {:role "assistant" :content [{:type "output_text" :text "<think>I should say hello</think>\nhello there!"}]}
                       {:role "user" :content [{:type "input_text" :text "how are you?"}]}]
               :instructions (m/pred string?)}
              (llm.mocks/get-req-body :reasoning-1)))))))

integration-test/integration/chat/google_test.clj

@@ -167,8 +167,7 @@
         (match-content chat-id "system" {:type "progress" :state "finished"})
         (is (match?
              {:input [{:role "user" :content [{:type "input_text" :text "hello!"}]}
-                      {:role "assistant" :content [{:type "output_text" :text "<thought>I should say hello</thought>"}]}
-                      {:role "assistant" :content [{:type "output_text" :text "hello there!"}]}
+                      {:role "assistant" :content [{:type "output_text" :text "<thought>I should say hello</thought>\nhello there!"}]}
                       {:role "user" :content [{:type "input_text" :text "how are you?"}]}]
               :instructions (m/pred string?)}
              (llm.mocks/get-req-body :reasoning-1)))))))

src/eca/llm_providers/openai_chat.clj

@@ -158,6 +158,7 @@
     "reason" (if (:delta-reasoning? content)
                ;; DeepSeek-style: reasoning_content must be passed back to API
                {:role "assistant"
+                :content ""
                 :reasoning_content (:text content)}
                ;; Fallback: wrap in thinking tags for models that use text-based reasoning
                {:role "assistant"
@@ -169,39 +170,66 @@
               :content (extract-content content supports-image?)}
     nil))
 
-(defn ^:private merge-reasoning-with-response
-  "Merge reasoning_content from prev with tool_calls/content from msg.
-   Required for DeepSeek which needs reasoning_content on same message as the response."
+(defn ^:private merge-assistant-messages
+  "Merge two assistant messages into one.
+   Concatenates contents and tool_calls, and preserves reasoning_content."
   [prev msg]
-  (cond-> {:role "assistant"
-           :reasoning_content (:reasoning_content prev)}
-    ;; content: from msg (DeepSeek's final answer)
-    (:content msg)
-    (assoc :content (:content msg))
-    ;; tool_calls: concatenate (prev may have some from earlier merge, msg adds more)
-    (or (:tool_calls prev) (:tool_calls msg))
-    (assoc :tool_calls (into (or (:tool_calls prev) []) (:tool_calls msg)))))
+  (let [prev-content (:content prev)
+        msg-content (:content msg)
+        blank-string? (fn [s] (and (string? s) (string/blank? s)))
+        combined-content (cond
+                           (nil? prev-content)
+                           msg-content
+
+                           (nil? msg-content)
+                           prev-content
+
+                           (blank-string? prev-content)
+                           msg-content
+
+                           (blank-string? msg-content)
+                           prev-content
+
+                           (and (string? prev-content) (string? msg-content))
+                           (if (or (string/ends-with? prev-content "\n")
+                                   (string/starts-with? msg-content "\n"))
+                             (str prev-content msg-content)
+                             (str prev-content "\n" msg-content))
+
+                           (and (sequential? prev-content) (sequential? msg-content))
+                           (vec (concat prev-content msg-content))
+
+                           :else
+                           (let [as-seq (fn [c] (if (sequential? c) c [{:type "text" :text (str c)}]))]
+                             (vec (concat (as-seq prev-content) (as-seq msg-content)))))]
+    (cond-> {:role "assistant"
+             :content (or combined-content "")}
+      (or (:reasoning_content prev) (:reasoning_content msg))
+      (assoc :reasoning_content (str (:reasoning_content prev) (:reasoning_content msg)))
+
+      (or (:tool_calls prev) (:tool_calls msg))
+      (assoc :tool_calls (vec (concat (:tool_calls prev)
+                                      (:tool_calls msg)))))))
 
 (defn ^:private merge-adjacent-assistants
-  "Merge adjacent assistant messages only when prev has reasoning_content.
-   This is required for DeepSeek which needs reasoning_content on same message as tool_calls/content."
+  "Merge all adjacent assistant messages.
+   This is required by many OpenAI-compatible APIs (including DeepSeek)
+   which do not allow multiple consecutive assistant messages."
   [messages]
   (reduce
    (fn [acc msg]
      (let [prev (peek acc)]
        (if (and (= "assistant" (:role prev))
-                (= "assistant" (:role msg))
-                (:reasoning_content prev))
-         (conj (pop acc) (merge-reasoning-with-response prev msg))
+                (= "assistant" (:role msg)))
+         (conj (pop acc) (merge-assistant-messages prev msg))
          (conj acc msg))))
    []
    messages))
 
 (defn ^:private valid-message?
   "Check if a message should be included in the final output."
-  [{:keys [role content tool_calls reasoning_content] :as msg}]
-  (and msg
-       (or (= role "tool") ; Never remove tool messages
+  [{:keys [role content tool_calls reasoning_content] :as _msg}]
+  (and (or (= role "tool") ; Never remove tool messages
            (seq tool_calls) ; Keep messages with tool calls
            (seq reasoning_content) ; Keep messages with reasoning_content (DeepSeek)
            (and (string? content)

test/eca/llm_providers/openai_chat_test.clj

@@ -8,11 +8,11 @@
 (def thinking-end-tag "</think>")
 
 (deftest normalize-messages-test
-  (testing "With tool_call history - tool calls stay separate from preceding assistant (no reasoning_content)"
+  (testing "With tool_call history - assistant text and tool calls are merged"
     (is (match?
          [{:role "user" :content [{:type "text" :text "List the files"}]}
-          {:role "assistant" :content [{:type "text" :text "I'll list the files for you"}]}
           {:role "assistant"
+           :content [{:type "text" :text "I'll list the files for you"}]
            :tool_calls [{:id "call-1"
                          :type "function"
                          :function {:name "eca__list_files"
@@ -36,11 +36,11 @@
           thinking-start-tag
           thinking-end-tag))))
 
-  (testing "Reason messages without reasoning-content use think tags, stay separate from following assistant"
+  (testing "Reason messages without reasoning-content use think tags, merged with following assistant"
     (is (match?
          [{:role "user" :content [{:type "text" :text "Hello"}]}
-          {:role "assistant" :content [{:type "text" :text "<think>Thinking...</think>"}]}
-          {:role "assistant" :content [{:type "text" :text "Hi"}]}]
+          {:role "assistant" :content [{:type "text" :text "<think>Thinking...</think>"}
+                                       {:type "text" :text "Hi"}]}]
          (#'llm-providers.openai-chat/normalize-messages
           [{:role "user" :content "Hello"}
            {:role "reason" :content {:text "Thinking..."}}
@@ -149,18 +149,42 @@
           thinking-end-tag)))))
 
 (deftest merge-adjacent-assistants-test
-  (testing "Without reasoning_content, adjacent assistants are NOT merged"
+  (testing "All adjacent assistant messages are merged (even without reasoning_content)"
     (is (match?
          [{:role "user" :content "What's the weather?"}
-          {:role "assistant" :tool_calls [{:id "call-1" :function {:name "get_weather"}}]}
-          {:role "assistant" :tool_calls [{:id "call-2" :function {:name "get_location"}}]}
+          {:role "assistant"
+           :content ""
+           :tool_calls [{:id "call-1" :function {:name "get_weather"}}
+                        {:id "call-2" :function {:name "get_location"}}]}
           {:role "user" :content "Thanks"}]
          (#'llm-providers.openai-chat/merge-adjacent-assistants
           [{:role "user" :content "What's the weather?"}
            {:role "assistant" :tool_calls [{:id "call-1" :function {:name "get_weather"}}]}
            {:role "assistant" :tool_calls [{:id "call-2" :function {:name "get_location"}}]}
            {:role "user" :content "Thanks"}]))))
 
+  (testing "Blank string content does not introduce leading newlines"
+    (is (match?
+         [{:role "user" :content "Hi"}
+          {:role "assistant" :content "Hello"}
+          {:role "user" :content "Thanks"}]
+         (#'llm-providers.openai-chat/merge-adjacent-assistants
+          [{:role "user" :content "Hi"}
+           {:role "assistant" :content ""}
+           {:role "assistant" :content "Hello"}
+           {:role "user" :content "Thanks"}]))))
+
+  (testing "DeepSeek: empty assistant content from reasoning does not add newlines to final content"
+    (is (match?
+         [{:role "user" :content "Q"}
+          {:role "assistant"
+           :reasoning_content "Thinking..."
+           :content "A"}]
+         (#'llm-providers.openai-chat/merge-adjacent-assistants
+          [{:role "user" :content "Q"}
+           {:role "assistant" :reasoning_content "Thinking..." :content ""}
+           {:role "assistant" :content "A"}]))))
+
   (testing "DeepSeek: Reasoning content merges with tool calls"
     (is (match?
          [{:role "user" :content "Calc"}