Support tool call approval and configuration to manual approval.

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Support tool call approval and configuration to manual approval.
+
 ## 0.7.0
 
 - Add client request to delete a chat.

docs/configuration.md

@@ -132,7 +132,10 @@ interface Config {
     rules: [{path: string;}];
     nativeTools: {
         {[key: string] {enabled: boolean}}
-    }
+    };
+    toolCall?: {
+      manualApproval?: boolean,
+    };
     mcpTimeoutSeconds: number;
     mcpServers: {[key: string]: {
         command: string;
@@ -174,6 +177,9 @@ interface Config {
   "nativeTools": {"filesystem": {"enabled": true}
                   "shell": {"enabled": true
                             "excludeCommands": []}},
+  "toolCall": {
+    "manualApproval": false,
+  },
   "mcpTimeoutSeconds" : 10,
   "mcpServers" : [],
   "customProviders": {},

docs/protocol.md

@@ -604,6 +604,32 @@ interface ToolCalledContent {
     }];
 }
 
+interface ToolCallRejected {
+    type: 'toolCallRejected';
+    
+    origin: ToolCallOrigin;
+    
+    /**
+     * id of the tool call
+     */
+    id: string;
+    
+    /**
+     * Name of the tool
+     */
+    name: string;
+    
+    /*
+     * Arguments of this tool call
+     */
+    arguments: {[key: string]: string};
+    
+    /**
+     * The reason why this tool call was rejected
+     */
+    reason: 'user';
+}
+
 type ToolCallOrigin = 'mcp' | 'native';
 ```
 
@@ -651,6 +677,54 @@ interface ChatQueryContextResponse {
 }
 ```
 
+### Chat approve tool call (➡️)
+
+A client notification for server to approve a waiting tool call.
+This will execute the tool call and continue the LLM chat loop.
+
+_Notification:_
+
+* method: `chat/toolCallApprove`
+* params: `ChatToolCallApproveParams` defined as follows:
+
+```typescript
+interface ChatToolCallApproveParams {
+    /**
+     * The chat session identifier.
+     */
+    chatId: string;
+    
+    /**
+     * The tool call identifier to approve.
+     */
+    toolCallId: string; 
+}
+```
+
+### Chat reject tool call (➡️)
+
+A client notification for server to reject a waiting tool call.
+This will not execute the tool call and return to the LLM chat loop.
+
+_Notification:_
+
+* method: `chat/toolCallReject`
+* params: `ChatToolCallRejectParams` defined as follows:
+
+```typescript
+interface ChatToolCallRejectParams {
+    /**
+     * The chat session identifier.
+     */
+    chatId: string;
+    
+    /**
+     * The tool call identifier to reject.
+     */
+    toolCallId: string; 
+}
+```
+
 ### Chat stop prompt (➡️)
 
 A client notification for server to stop the current chat prompt with LLM if running.

src/eca/features/chat.clj

@@ -120,6 +120,7 @@
                            (:workspace-folders db)
                            {:behavior (behavior->behavior-str (or behavior (:chat-default-behavior db)))})
         refined-contexts (raw-contexts->refined contexts)
+        manual-approval? (get-in config [:toolCall :manualApproval] false)
         context-str (build-context-str refined-contexts rules)
         chosen-model (or model (default-model db config))
         past-messages (get-in db [:chats chat-id :messages] [])
@@ -221,7 +222,7 @@
                                           :origin (tool-name->origin name all-tools)
                                           :arguments-text (get @tool-call-args-by-id* id)
                                           :id id
-                                          :manual-approval false}}))
+                                          :manual-approval manual-approval?}}))
       :on-tool-called (fn [{:keys [id name arguments] :as tool-call}]
                         (assert-chat-not-stopped! chat-id db* messenger)
                         (messenger/chat-content-received
@@ -234,27 +235,66 @@
                                     :origin (tool-name->origin name all-tools)
                                     :arguments arguments
                                     :id id
-                                    :manual-approval false}})
-                        (let [result (f.tools/call-tool! name arguments @db* config)]
+                                    :manual-approval manual-approval?}})
+                        (let [approved?* (promise)]
+                          (swap! db* assoc-in [:chats chat-id :tool-calls id :approved?*] approved?*)
                           (when-not (string/blank? @received-msgs*)
                             (add-to-history! {:role "assistant" :content @received-msgs*})
                             (reset! received-msgs* ""))
-                          (add-to-history! {:role "tool_call" :content tool-call})
-                          (add-to-history! {:role "tool_call_output" :content (assoc tool-call :output result)})
-                          (swap! tool-call-args-by-id* dissoc id)
-                          (messenger/chat-content-received
-                           messenger
-                           {:chat-id chat-id
-                            :request-id request-id
-                            :role :assistant
-                            :content {:type :toolCalled
-                                      :origin (tool-name->origin name all-tools)
-                                      :name name
-                                      :arguments arguments
-                                      :id id
-                                      :outputs (:contents result)}})
-                          {:result result
-                           :past-messages (get-in @db* [:chats chat-id :messages] [])}))
+                          (if manual-approval?
+                            (messenger/chat-content-received
+                             messenger
+                             {:chat-id chat-id
+                              :request-id request-id
+                              :role :system
+                              :content {:type :progress
+                                        :state :running
+                                        :text "Waiting for tool call approval"}})
+                            ;; Otherwise auto approve
+                            (deliver approved?* true))
+                          (if @approved?*
+                            (let [output (f.tools/call-tool! name arguments @db* config)]
+                              (add-to-history! {:role "tool_call" :content tool-call})
+                              (add-to-history! {:role "tool_call_output" :content (assoc tool-call :output output)})
+                              (swap! tool-call-args-by-id* dissoc id)
+                              (messenger/chat-content-received
+                               messenger
+                               {:chat-id chat-id
+                                :request-id request-id
+                                :role :assistant
+                                :content {:type :toolCalled
+                                          :origin (tool-name->origin name all-tools)
+                                          :name name
+                                          :arguments arguments
+                                          :id id
+                                          :outputs (:contents output)}})
+                              {:new-messages (get-in @db* [:chats chat-id :messages])})
+                            (do
+                              (add-to-history! {:role "tool_call" :content tool-call})
+                              (add-to-history! {:role "tool_call_output" :content (assoc tool-call :output {:contents [{:content "Tool call rejected by user"
+                                                                                                                        :error true
+                                                                                                                        :type :text}]})})
+                              (swap! tool-call-args-by-id* dissoc id)
+                              (messenger/chat-content-received
+                               messenger
+                               {:chat-id chat-id
+                                :request-id request-id
+                                :role :system
+                                :content {:type :progress
+                                          :state :running
+                                          :text "Generating"}})
+                              (messenger/chat-content-received
+                               messenger
+                               {:chat-id chat-id
+                                :request-id request-id
+                                :role :assistant
+                                :content {:type :toolCallRejected
+                                          :origin (tool-name->origin name all-tools)
+                                          :name name
+                                          :arguments arguments
+                                          :reason :user
+                                          :id id}})
+                              {:new-messages (get-in @db* [:chats chat-id :messages])}))))
       :on-reason (fn [{:keys [status]}]
                    (assert-chat-not-stopped! chat-id db* messenger)
                    (let [msg (case status
@@ -282,6 +322,12 @@
      :model chosen-model
      :status :success}))
 
+(defn tool-call-approve [{:keys [chat-id tool-call-id]} db*]
+  (deliver (get-in @db* [:chats chat-id :tool-calls tool-call-id :approved?*]) true))
+
+(defn tool-call-reject [{:keys [chat-id tool-call-id]} db*]
+  (deliver (get-in @db* [:chats chat-id :tool-calls tool-call-id :approved?*]) false))
+
 (defn ^:private contexts-for [root-filename query config]
   (let [all-files (fs/glob root-filename (str "**" (or query "") "**"))
         allowed-files (f.index/filter-allowed all-files root-filename config)]

src/eca/handlers.clj

@@ -74,10 +74,20 @@
    :eca/chat-query-context
    (f.chat/query-context params db* config)))
 
+(defn chat-tool-call-approve [{:keys [db*]} params]
+  (logger/logging-task
+   :eca/chat-tool-call-approve
+   (f.chat/tool-call-approve params db*)))
+
+(defn chat-tool-call-reject [{:keys [db*]} params]
+  (logger/logging-task
+   :eca/chat-tool-call-reject
+   (f.chat/tool-call-reject params db*)))
+
 (defn chat-prompt-stop [{:keys [db* messenger]} params]
   (logger/logging-task
-   :eca/chat-prompt-stop
-   (f.chat/prompt-stop params db* messenger)))
+      :eca/chat-prompt-stop
+      (f.chat/prompt-stop params db* messenger)))
 
 (defn chat-delete [{:keys [db*]} params]
   (logger/logging-task

src/eca/llm_providers/anthropic.clj

@@ -124,10 +124,10 @@
                                            (when (= "tool_use" (:type content-block))
                                              (let [function-name (:name content-block)
                                                    function-args (:input-json content-block)
-                                                   {:keys [past-messages]} (on-tool-called {:id (:id content-block)
-                                                                                            :name function-name
-                                                                                            :arguments (json/parse-string function-args)})
-                                                   messages (-> (past-messages->messages past-messages)
+                                                   {:keys [new-messages]} (on-tool-called {:id (:id content-block)
+                                                                                           :name function-name
+                                                                                           :arguments (json/parse-string function-args)})
+                                                   messages (-> (past-messages->messages new-messages)
                                                                 add-cache-to-last-message)]
                                                (base-request!
                                                 {:rid (llm-util/gen-rid)

src/eca/llm_providers/ollama.clj

@@ -101,12 +101,12 @@
 
                              done_reason
                              (if-let [tool-call (get @tool-calls* rid)]
-                               (let [{:keys [past-messages]} (on-tool-called tool-call)]
+                               (let [{:keys [new-messages]} (on-tool-called tool-call)]
                                  (swap! tool-calls* dissoc rid)
                                  (base-completion-request!
                                   {:rid (llm-util/gen-rid)
                                    :url url
-                                   :body (assoc body :messages (past-messages->messages past-messages context))
+                                   :body (assoc body :messages (past-messages->messages new-messages context))
                                    :on-error on-error
                                    :on-response handle-response}))
                                (on-message-received {:type :finish

src/eca/llm_providers/openai.clj

@@ -86,10 +86,10 @@
             (case (:type (:item data))
               "function_call" (let [function-name (-> data :item :name)
                                     function-args (-> data :item :arguments)
-                                    {:keys [past-messages]} (on-tool-called {:id (-> data :item :call_id)
-                                                                             :name function-name
-                                                                             :arguments (json/parse-string function-args)})
-                                    input (past-messages->input past-messages)]
+                                    {:keys [new-messages]} (on-tool-called {:id (-> data :item :call_id)
+                                                                            :name function-name
+                                                                            :arguments (json/parse-string function-args)})
+                                    input (past-messages->input new-messages)]
                                 (base-completion-request!
                                  {:rid (llm-util/gen-rid)
                                   :body (assoc body :input input)

src/eca/server.clj

@@ -49,6 +49,12 @@
 (defmethod lsp.server/receive-request "chat/queryContext" [_ components params]
   (handlers/chat-query-context (with-config components) params))
 
+(defmethod lsp.server/receive-notification "chat/toolCallApprove" [_ components params]
+  (handlers/chat-tool-call-approve (with-config components) params))
+
+(defmethod lsp.server/receive-notification "chat/toolCallReject" [_ components params]
+  (handlers/chat-tool-call-reject (with-config components) params))
+
 (defmethod lsp.server/receive-notification "chat/promptStop" [_ components params]
   (handlers/chat-prompt-stop (with-config components) params))