Simplify reasoning callback, fix tool call parse error loop

- Use :delta-reasoning? boolean directly instead of deriving from
  (some? reasoning-content)
- Fix infinite loop when tool JSON is truncated - check valid-tools
  not completed-tools before continuing conversation

Author: zikajk

src/eca/features/chat.clj

@@ -1130,7 +1130,7 @@
                                                               :arguments-text arguments-text
                                                               :summary (f.tools/tool-call-summary all-tools full-name nil config)})))
             :on-tools-called (on-tools-called! chat-ctx received-msgs* add-to-history!)
-            :on-reason (fn [{:keys [status id text external-id reasoning-content]}]
+            :on-reason (fn [{:keys [status id text external-id delta-reasoning?]}]
                          (assert-chat-not-stopped! chat-ctx)
                          (case status
                            :started  (do (swap! reasonings* assoc-in [id :start-time] (System/currentTimeMillis))
@@ -1142,7 +1142,7 @@
                                          (add-to-history! {:role "reason"
                                                            :content {:id id
                                                                      :external-id external-id
-                                                                     :delta-reasoning? (some? reasoning-content)
+                                                                     :delta-reasoning? delta-reasoning?
                                                                      :total-time-ms total-time-ms
                                                                      :text (get-in @reasonings* [id :text])}})
                                          (send-content! chat-ctx :assistant {:type :reasonFinished :total-time-ms total-time-ms :id id})))

src/eca/llm_api.clj

@@ -273,7 +273,7 @@
                 (on-reason-wrapper {:status :thinking :id reason-id :text reason-text})
                 (on-reason-wrapper {:status :finished
                                     :id reason-id
-                                    :reasoning-content reasoning-content}))
+                                    :delta-reasoning? (some? reasoning-content)}))
               (on-message-received-wrapper {:type :text :text output-text})
               (some-> usage (on-usage-updated))
               (if-let [new-result (when (seq tools-to-call)

src/eca/llm_providers/openai_chat.clj

@@ -227,20 +227,20 @@
   (let [all-accumulated (vals @tool-calls*)
         completed-tools (->> all-accumulated
                              (filter #(every? % [:id :full-name :arguments-text]))
-                             (map (fn [{:keys [arguments-text name] :as tool-call}]
+                             (map (fn [{:keys [arguments-text full-name] :as tool-call}]
                                     (try
                                       (assoc tool-call :arguments (json/parse-string arguments-text))
                                       (catch Exception e
                                         (let [error-msg (format "Failed to parse JSON arguments for tool '%s': %s"
-                                                                name (ex-message e))]
+                                                                full-name (ex-message e))]
                                           (logger/warn logger-tag error-msg)
                                           (assoc tool-call :arguments {} :parse-error error-msg)))))))
         ;; Filter out tool calls with parse errors to prevent execution with invalid data
         valid-tools (remove :parse-error completed-tools)]
-    (if (seq completed-tools)
-      ;; We have some completed tools (valid or with errors), so continue the conversation
+    (if (seq valid-tools)
+      ;; We have valid tools to execute, continue the conversation
       (on-tools-called-wrapper valid-tools on-tools-called handle-response)
-      ;; No completed tools at all - let the streaming response provide the actual finish_reason
+      ;; No valid tools (all had parse errors or none accumulated) - don't loop
       nil)))
 
 (defn ^:private process-text-think-aware
@@ -314,11 +314,9 @@
   [reasoning-state* on-reason]
   (let [state @reasoning-state*]
     (when (and (:type state) (:id state))
-      (let [accumulated-reasoning (when (= (:type state) :delta)
-                                    (not-empty (:content state)))]
-        (on-reason (cond-> {:status :finished :id (:id state)}
-                     accumulated-reasoning
-                     (assoc :reasoning-content accumulated-reasoning)))))
+      (on-reason {:status :finished
+                  :id (:id state)
+                  :delta-reasoning? (= (:type state) :delta)}))
     (reset! reasoning-state* {:id nil :type nil :content "" :buffer ""})))
 
 (defn ^:private prune-history
@@ -441,17 +439,11 @@
                                   ;; Process reasoning if present (o1 models and compatible providers)
                                   (when-let [reasoning-text (or (:reasoning delta)
                                                                 (:reasoning_content delta))]
-                                    (let [state @reasoning-state*]
-                                      (when-not (= (:type state) :delta)
-                                        (start-delta-reasoning))
-                                      ;; Get current state after potentially starting delta reasoning
-                                      (let [current-state @reasoning-state*]
-                                        ;; Accumulate reasoning_content (needed for providers that require echoing it back)
-                                        (when (:reasoning_content delta)
-                                          (swap! reasoning-state* update :content str reasoning-text))
-                                        (on-reason {:status :thinking
-                                                    :id (:id current-state)
-                                                    :text reasoning-text}))))
+                                    (when-not (= (:type @reasoning-state*) :delta)
+                                      (start-delta-reasoning))
+                                    (on-reason {:status :thinking
+                                                :id (:id @reasoning-state*)
+                                                :text reasoning-text}))
 
                                   ;; Check if reasoning just stopped (delta-based)
                                   (let [state @reasoning-state*]

test/eca/llm_providers/openai_chat_test.clj

@@ -372,22 +372,61 @@
       (#'llm-providers.openai-chat/finish-reasoning! reasoning-state* on-reason)
       (is (not @on-reason-called?) "on-reason should not be called when :id is nil"))))
 
+(deftest execute-accumulated-tools-with-parse-errors-test
+  (testing "When all tools have parse errors, should NOT call on-tools-called-wrapper (prevents infinite loop)"
+    (let [tool-calls* (atom {"rid-0" {:index 0
+                                      :id "call-123"
+                                      :full-name "eca__write_file"
+                                      :arguments-text "{\"path\": \"/tmp/test.txt\", \"content\": \"truncated..."}}) ;; Invalid JSON
+          wrapper-called? (atom false)
+          on-tools-called-wrapper (fn [& _] (reset! wrapper-called? true))]
+      (#'llm-providers.openai-chat/execute-accumulated-tools!
+       tool-calls*
+       on-tools-called-wrapper
+       (fn [_] {:new-messages []})
+       (fn [& _]))
+      ;; The wrapper should NOT be called because there are no valid tools
+      (is (not @wrapper-called?)
+          "on-tools-called-wrapper should NOT be called when all tools have parse errors")))
+
+  (testing "When some tools are valid and some have errors, should call wrapper with valid tools only"
+    (let [tool-calls* (atom {"rid-0" {:index 0
+                                      :id "call-123"
+                                      :full-name "eca__read_file"
+                                      :arguments-text "{\"path\": \"/tmp/test.txt\"}"}  ;; Valid JSON
+                             "rid-1" {:index 1
+                                      :id "call-456"
+                                      :full-name "eca__write_file"
+                                      :arguments-text "{\"path\": \"truncated..."}})  ;; Invalid JSON
+          passed-tools (atom nil)
+          on-tools-called-wrapper (fn [tools & _] (reset! passed-tools tools))]
+      (#'llm-providers.openai-chat/execute-accumulated-tools!
+       tool-calls*
+       on-tools-called-wrapper
+       (fn [_] {:new-messages []})
+       (fn [& _]))
+      ;; Should be called with only the valid tool
+      (is (= 1 (count @passed-tools)))
+      (is (= "call-123" (:id (first @passed-tools)))))))
+
 (deftest deepseek-non-stream-reasoning-content-test
   (testing "response-body->result captures reasoning_content and normalization uses :text with :delta-reasoning?"
     (let [body {:usage {:prompt_tokens 5 :completion_tokens 2}
                 :choices [{:message {:content "hi"
                                      :reasoning_content "think more"}}]}
           result (#'llm-providers.openai-chat/response-body->result body (fn [& _]))
           ;; Simulate how chat.clj would store this: :text has the content, :delta-reasoning? is the flag
+          ;; In non-streaming, llm_api.clj converts (some? reasoning-content) to :delta-reasoning?
           normalized (#'llm-providers.openai-chat/normalize-messages
                       [{:role "user" :content "Q"}
                        {:role "reason" :content {:id "r1"
-                                                 :text (:reasoning-content result)
-                                                 :delta-reasoning? true}}]
+                                                 :text (:reason-text result)
+                                                 :delta-reasoning? (some? (:reasoning-content result))}}]
                       true
                       thinking-start-tag
                       thinking-end-tag)]
-      (is (= "think more" (:reasoning-content result)))
+      (is (= "think more" (:reason-text result)))
+      (is (some? (:reasoning-content result)) "reasoning-content should be present in non-streaming result")
       (is (match?
            [{:role "user" :content [{:type "text" :text "Q"}]}
             {:role "assistant"