Fix thinking for claude

Author: ericdallo

src/eca/features/chat.clj

@@ -101,6 +101,7 @@
         user-prompt message
         all-tools (f.tools/all-tools @db* config)
         received-msgs* (atom "")
+        received-thinking* (atom "")
         tool-call-args-by-id* (atom {})
         add-to-history! (fn [msg]
                           (swap! db* update-in [:chats chat-id :messages] (fnil conj []) msg))
@@ -218,19 +219,24 @@
                                               :reason :user
                                               :id id})
                               {:new-messages (get-in @db* [:chats chat-id :messages])}))))
-      :on-reason (fn [{:keys [status id text]}]
+      :on-reason (fn [{:keys [status id text external-id]}]
                    (assert-chat-not-stopped! chat-ctx)
                    (case status
                      :started (send-content! chat-ctx :assistant
                                              {:type :reasonStarted
                                               :id id})
-                     :thinking (send-content! chat-ctx :assistant
-                                              {:type :reasonText
-                                               :id id
-                                               :text text})
-                     :finished (send-content! chat-ctx :assistant
-                                              {:type :reasonFinished
-                                               :id id})
+                     :thinking (do
+                                 (swap! received-thinking* str text)
+                                 (send-content! chat-ctx :assistant
+                                                {:type :reasonText
+                                                 :id id
+                                                 :text text}))
+                     :finished (do
+                                 (add-to-history! {:role "reason" :content {:external-id external-id
+                                                                            :text @received-thinking*}})
+                                 (send-content! chat-ctx :assistant
+                                                {:type :reasonFinished
+                                                 :id id}))
                      nil))
       :on-error (fn [{:keys [message exception]}]
                   (send-content! chat-ctx :system

src/eca/llm_api.clj

@@ -76,6 +76,9 @@
         on-message-received-wrapper (fn [& args]
                                       (apply emit-first-message-fn args)
                                       (apply on-message-received args))
+        on-reason-wrapper (fn [& args]
+                            (apply emit-first-message-fn args)
+                            (apply on-reason args))
         on-prepare-tool-call-wrapper (fn [& args]
                                        (apply emit-first-message-fn args)
                                        (apply on-prepare-tool-call args))
@@ -96,7 +99,7 @@
                    :on-error on-error-wrapper
                    :on-prepare-tool-call on-prepare-tool-call-wrapper
                    :on-tool-called on-tool-called
-                   :on-reason on-reason}]
+                   :on-reason on-reason-wrapper}]
     (cond
       (contains? #{"o4-mini"
                    "o3"

src/eca/llm_providers/anthropic.clj

@@ -67,6 +67,11 @@
              :content [{:type "tool_result"
                         :tool_use_id (:id content)
                         :content (llm-util/stringfy-tool-result content)}]}
+            "reason"
+            {:role "assistant"
+             :content [{:type "thinking"
+                        :signature (:external-id content)
+                        :thinking (:text content)}]}
             msg))
         past-messages))
 
@@ -111,12 +116,6 @@
                                                  (swap! content-block* assoc (:index data) (:content_block data)))
 
                                     nil)
-            "content_block_stop" (when-let [content-block (get @content-block* (:index data))]
-                                   (case (:type content-block)
-                                     "thinking" (on-reason {:status :finished
-                                                            :id reason-id})
-                                     nil)
-                                   (swap! content-block* dissoc (:index data)))
             "content_block_delta" (case (-> data :delta :type)
                                     "text_delta" (on-message-received {:type :text
                                                                        :text (-> data :delta :text)})
@@ -135,7 +134,10 @@
                                     "thinking_delta" (on-reason {:status :thinking
                                                                  :id reason-id
                                                                  :text (-> data :delta :thinking)})
-                                    (logger/warn "Unkown response delta type" (-> data :delta :type)))
+                                    "signature_delta" (on-reason {:status :finished
+                                                                  :external-id (-> data :delta :signature)
+                                                                  :id reason-id})
+                                    nil)
             "message_delta" (case (-> data :delta :stop_reason)
                               "tool_use" (doseq [content-block (vals @content-block*)]
                                            (when (= "tool_use" (:type content-block))
@@ -154,10 +156,12 @@
                                                  :content-block* (atom nil)
                                                  :on-error on-error
                                                  :on-response handle-response}))))
-                              "end_turn" (on-message-received {:type :finish
-                                                               :usage {:input-tokens (-> data :usage :input_tokens)
-                                                                       :output-tokens (-> data :usage :output_tokens)}
-                                                               :finish-reason (-> data :delta :stop_reason)})
+                              "end_turn" (do
+                                           (reset! content-block* {})
+                                           (on-message-received {:type :finish
+                                                                 :usage {:input-tokens (-> data :usage :input_tokens)
+                                                                         :output-tokens (-> data :usage :output_tokens)}
+                                                                 :finish-reason (-> data :delta :stop_reason)}))
                               "max_tokens" (on-message-received {:type :limit-reached
                                                                  :tokens (:usage data)})
                               nil)