Support "accept and remember" tool call per session and name.

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Support "accept and remember" tool call per session and name.
+
 ## 0.62.1
 
 - Add `claude-sonnet-4.5` for github-copilot provider.

docs/protocol.md

@@ -929,6 +929,11 @@ interface ChatToolCallApproveParams {
      */
     chatId: string;
 
+    /**
+     * The approach to save this tool call.
+     */
+    save?: 'session';
+
     /**
      * The tool call identifier to approve.
      */

src/eca/features/chat.clj

@@ -530,7 +530,7 @@
                                          details (f.tools/tool-call-details-before-invocation name arguments)
                                          summary (f.tools/tool-call-summary all-tools name arguments config)
                                          origin (tool-name->origin name all-tools)
-                                         approval (f.tools/approval all-tools name arguments db config behavior)
+                                         approval (f.tools/approval all-tools name arguments @db* config behavior)
                                          ask? (= :ask approval)]
                                      ;; assert: In :preparing or :stopping or :stopped
                                      ;; Inform client the tool is about to run and store approval promise
@@ -799,22 +799,21 @@
      :model full-model
      :status :prompting}))
 
-(defn tool-call-approve [{:keys [chat-id tool-call-id request-id]} db* messenger metrics]
-  (let [chat-ctx {;; What else is needed?
-                  :chat-id chat-id
+(defn tool-call-approve [{:keys [chat-id tool-call-id save]} db* messenger metrics]
+  (let [chat-ctx {:chat-id chat-id
                   :db* db*
                   :metrics metrics
-                  :request-id request-id
                   :messenger messenger}]
     (transition-tool-call! db* chat-ctx tool-call-id :user-approve
                            {:reason {:code :user-choice-allow
-                                     :text "Tool call allowed by user choice"}})))
+                                     :text "Tool call allowed by user choice"}})
+    (when (= "session" save)
+      (let [tool-call-name (get-in @db* [:chats chat-id :tool-calls tool-call-id :name])]
+        (swap! db* assoc-in [:tool-calls tool-call-name :remember-to-approve?] true)))))
 
-(defn tool-call-reject [{:keys [chat-id tool-call-id request-id]} db* messenger metrics]
-  (let [chat-ctx {;; What else is needed?
-                  :chat-id chat-id
+(defn tool-call-reject [{:keys [chat-id tool-call-id]} db* messenger metrics]
+  (let [chat-ctx {:chat-id chat-id
                   :db* db*
-                  :request-id request-id
                   :metrics metrics
                   :messenger messenger}]
     (transition-tool-call! db* chat-ctx tool-call-id :user-reject

src/eca/features/tools.clj

@@ -189,14 +189,18 @@
   "Return the approval keyword for the specific tool call: ask, allow or deny.
    Behavior parameter is required - pass nil for global-only approval rules."
   [all-tools tool-call-name args db config behavior]
-  (let [{:keys [server require-approval-fn]} (first (filter #(= tool-call-name (:name %))
+  (let [remember-to-approve? (get-in db [:tool-calls tool-call-name :remember-to-approve?])
+        {:keys [server require-approval-fn]} (first (filter #(= tool-call-name (:name %))
                                                             all-tools))
         {:keys [allow ask deny byDefault]}   (merge (get-in config [:toolCall :approval])
                                                     (get-in config [:behavior behavior :toolCall :approval]))]
     (cond
       (and require-approval-fn (require-approval-fn args {:db db}))
       :ask
 
+      remember-to-approve?
+      :allow
+
       (some #(approval-matches? % server tool-call-name args) deny)
       :deny
 

test/eca/features/tools_test.clj

@@ -88,7 +88,7 @@
       (is (= #{"plan_tool"}
              (#'f.tools/get-disabled-tools config "plan"))))))
 
-(deftest manual-approval?-test
+(deftest approval-test
   (let [all-tools [{:name "eca_read" :server "eca"}
                    {:name "eca_write" :server "eca"}
                    {:name "eca_shell" :server "eca" :require-approval-fn (constantly true)}
@@ -99,6 +99,8 @@
       (is (= :ask (f.tools/approval all-tools "eca_shell" {} {} {} nil))))
     (testing "tool has require-approval-fn which returns false we ignore it"
       (is (= :ask (f.tools/approval all-tools "eca_plan" {} {} {} nil))))
+    (testing "tool was remembered to approve by user"
+      (is (= :allow (f.tools/approval all-tools "eca_plan" {} {:tool-calls {"eca_plan" {:remember-to-approve? true}}} {} nil))))
     (testing "if legacy-manual-approval present, considers it"
       (is (= :ask (f.tools/approval all-tools "request" {} {} {:toolCall {:manualApproval true}} nil))))
     (testing "if approval config is provided"