Fix tool call output

Author: ericdallo

CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ## Unreleased
 
-- Support user configured custom tools.
+- Support user configured custom tools via `customTools` config.
 
 ## 0.44.1
 

src/eca/features/tools/custom.clj

@@ -1,27 +1,53 @@
 (ns eca.features.tools.custom
   (:require
-   [babashka.process :as process]
-   [clojure.string :as string]))
+   [babashka.process :as p]
+   [clojure.string :as string]
+   [eca.features.tools.util :as tools.util]
+   [eca.logger :as logger]
+   [eca.shared :as shared]))
 
 (set! *warn-on-reflection* true)
 
+(def ^:private logger-tag "[CUSTOM-TOOLS]")
+
 (defn ^:private build-tool-fn
   "Creates a function that safely executes the command from a custom tool config.
   It substitutes {{placeholders}} in the command vector with LLM-provided arguments."
   [{:keys [command]}]
-  ;; The handler function takes arguments and a context map. We only need the arguments.
-  (fn [llm-args _context]
-    (let [resolved-command (mapv
-                            (fn [part]
-                              (if (and (string? part) (string/starts-with? part "{{") (string/ends-with? part "}}"))
-                                (let [key-name (keyword (subs part 2 (- (count part) 2)))]
-                                  (str (get llm-args key-name "")))
-                                part))
-                            command)
-          {:keys [out exit]} (process/sh resolved-command {:error-to-out true})]
+  (fn [args {:keys [db]}]
+    (let [resolved-command (reduce
+                            (fn [s [arg-name arg-value]]
+                              (string/replace s (str "{{" arg-name "}}") arg-value))
+                            command
+                            args)
+          work-dir (some-> (:workspace-folders db)
+                           first
+                           :uri
+                           shared/uri->filename)
+          _ (logger/debug logger-tag "Running custom tool:" resolved-command)
+          result (try
+                   (p/shell {:dir work-dir
+                             :out :string
+                             :err :string
+                             :continue true} "bash -c" resolved-command)
+                   (catch Exception e
+                     {:exit 1 :err (.getMessage e)}))
+          exit (:exit result)
+          err (some-> (:err result) string/trim)
+          out (some-> (:out result) string/trim)]
+      (logger/debug logger-tag "custom tool executed:" result)
       (if (zero? exit)
-        out
-        (str "Error: Command failed with exit code " exit "\nOutput:\n" out)))))
+        (tools.util/single-text-content out)
+        {:error true
+         :contents (remove nil?
+                           (concat [{:type :text
+                                     :text (str "Exit code " exit)}]
+                                   (when-not (string/blank? err)
+                                     [{:type :text
+                                       :text (str "Stderr:\n" err)}])
+                                   (when-not (string/blank? out)
+                                     [{:type :text
+                                       :text (str "Stdout:\n" out)}])))}))))
 
 (defn ^:private custom-tool->tool-def
   "Transforms a single custom tool from the config map into a full tool definition."

test/eca/features/tools/custom_test.clj

@@ -1,50 +1,49 @@
 (ns eca.features.tools.custom-test
   (:require
-   [clojure.string :as string]
+   [babashka.process :as p]
    [clojure.test :refer [deftest is testing]]
-   [babashka.process :as process]
    [eca.features.tools.custom :as f.tools.custom]))
 
 (deftest definitions-test
   (testing "when a valid tool is configured"
     (let [mock-custom-tools {"file-search"
                              {:description "Finds files."
-                              :command     ["find" "{{directory}}" "-name" "{{pattern}}"]
-                              :schema      {:properties {:directory {:type "string"}
-                                                         :pattern   {:type "string"}}
+                              :command     "find {{directory}} -name {{pattern}}"
+                              :schema      {:properties {"directory" {:type "string"}
+                                                         "pattern"   {:type "string"}}
                                             :required    ["directory" "pattern"]}}}]
       (testing "and the command executes successfully"
-        (with-redefs [process/sh (fn [command-vec & _]
-                                   (is (= ["find" "/tmp" "-name" "*.clj"] command-vec))
-                                   {:out "mocked-output" :exit 0})]
+        (with-redefs [p/shell (fn [_opts _bash command]
+                                (is (= "find /tmp -name *.clj" command))
+                                {:out "mocked-output" :exit 0})]
           (let [config {:customTools mock-custom-tools}
                 custom-defs (f.tools.custom/definitions config)
                 custom-tool-def (get custom-defs "file-search")]
             (is (some? custom-tool-def) "The custom tool should be loaded.")
-            (let [result ((:handler custom-tool-def) {:directory "/tmp" :pattern "*.clj"} {})]
-              (is (= "mocked-output" result) "The tool should return the mocked shell output.")))))))
+            (let [result ((:handler custom-tool-def) {"directory" "/tmp" "pattern" "*.clj"} {})]
+              (is (= {:contents [{:text "mocked-output", :type :text}], :error false} result) "The tool should return the mocked shell output.")))))))
 
   (testing "when multiple tools are configured"
     (let [mock-custom-tools {"git-status"
                              {:description "Gets git status"
-                              :command ["git" "status"]}
+                              :command "git status"}
                              "echo-message"
                              {:description "Echoes a message"
-                              :command ["echo" "{{message}}"]
-                              :schema {:properties {:message {:type "string"}} :required ["message"]}}}]
-      (with-redefs [process/sh (fn [command-vec & _]
-                                 (condp = command-vec
-                                   ["git" "status"] {:out "On branch main" :exit 0}
-                                   ["echo" "Hello World"] {:out "Hello World" :exit 0}
-                                   (is false "Unexpected command received by mock p/sh")))]
+                              :command "echo {{message}}"
+                              :schema {:properties {"message" {:type "string"}} :required ["message"]}}}]
+      (with-redefs [p/shell (fn [_opts _bash command]
+                              (condp = command
+                                "git status" {:out "On branch main" :exit 0}
+                                "echo Hello World" {:out "Hello World" :exit 0}
+                                (is false "Unexpected command received by mock p/sh")))]
         (let [config {:customTools mock-custom-tools}
               custom-defs (f.tools.custom/definitions config)
               git-status-handler (get-in custom-defs ["git-status" :handler])
               echo-handler (get-in custom-defs ["echo-message" :handler])]
           (is (some? git-status-handler) "Git status tool should be loaded.")
           (is (some? echo-handler) "Echo message tool should be loaded.")
-          (is (= "On branch main" (git-status-handler {} {})))
-          (is (= "Hello World" (echo-handler {:message "Hello World"} {})))))))
+          (is (= {:contents [{:text "On branch main", :type :text}], :error false} (git-status-handler {} {})))
+          (is (= {:contents [{:text "Hello World", :type :text}], :error false} (echo-handler {"message" "Hello World"} {})))))))
 
   (testing "when the custom tools config is empty or missing"
     (testing "with an empty map"