Emit llm-tool-call-request frame when the LLM requests a tool call

Author: ovistoica

CHANGELOG.md

@@ -22,6 +22,7 @@ All notable changes to this project will be documented in this file. This change
 - **Transport In (twilio, async and microphone**: Moved params parsing to use malli schemas, see the schemas defined [here](./src/simulflow/transport/in.clj).
 - **Examples**: Added example of local microphone AI agent with interruption capability. See [here](./examples/src/simulflow_examples/local_w_interruption_support.clj)
 - **Transport In (twilio, async and microphone)**: Added muting support. When transports receive `mute-input-start`, the input isn't processed further and processing resumes when `mute-input-stop` frame is received. Useful for guided conversations where you don't want the user to speak over the bot, during initial greetings or during function calls.
+- **User Context Aggregator**: Now emits `frame/llm-tool-call-request` when a the llm requests a tool call. This frame can be used to make the agent say something while the tool handler is called, or trigger a mute filter while executing tool call.
 
 ### Changed
 - Moved most of the llm logic from [openai processor](./src/simulflow/processors/openai.clj) to an utils folder to be used by multiple processors like [gemini](./src/simulflow/processors/google.clj)

src/simulflow/frame.clj

@@ -419,7 +419,9 @@
                      ::scenario-context-update
                      ::speak-frame
                      ::mute-input-start
-                     ::mute-input-stop})
+                     ::mute-input-stop
+                     ::llm-tool-call-request
+                     ::llm-tool-call-result})
 
 (defn system-frame?
   "Returns true if the frame is a system frame that should be processed immediately"

src/simulflow/processors/llm_context_aggregator.clj

@@ -181,10 +181,12 @@
       (frame/llm-context-messages-append? frame)
       ,(let [{new-messages :messages
               opts :properties} (:frame/data frame)
-             nc (update-in (:llm/context state) [:messages] into new-messages)]
+             nc (update-in (:llm/context state) [:messages] into new-messages)
+             tool-request-message (first (filter #(seq (:tool_calls %)) new-messages))]
          [(assoc state :llm/context nc) (cond-> {}
                                           ;; if it's a tool call, send to the tool-caller to obtain the result
-                                          (:tool-call? opts) (assoc :tool-write [(frame/llm-context nc)])
+                                          (:tool-call? opts) (assoc :tool-write [(frame/llm-context nc)]
+                                                                    :sys-out [(frame/llm-tool-call-request tool-request-message)])
                                           ;; send new context further to the LLM
                                           (:run-llm? opts) (assoc :out [(frame/llm-context nc)]))])
 
@@ -289,7 +291,7 @@
                                         :function-arguments nil
                                         :tool-call-id nil)
 
-        id "assistant-context-assembler"]
+        id :assistant-context-assembler]
     (cond
 
       (frame/llm-full-response-start? frame)

test/simulflow/processors/llm_context_aggregator_test.clj

@@ -258,32 +258,36 @@
                      (get-in (first out) [:frame/data :messages]))))
 
             ;; Case 2: Append with tool call
-            (let [[new-state {:keys [out tool-write]}]
-                  (sut/context-aggregator-transform
-                    state nil
-                    (frame/llm-context-messages-append
-                      {:messages (conj new-messages tool-request)
-                       :properties {:tool-call? true
-                                    :run-llm? false}}))]
-
-              ;; Check state update
-              (is (= [{:role :system :content "Initial context"}
-                      {:role :user :content "Hello"}
-                      {:role :assistant :content "Hi there"}
-                      tool-request]
-                     (get-in new-state [:llm/context :messages])))
-
-              ;; Check if message was sent to tool-write channel
-              (is (= 1 (count tool-write)))
-              (is (frame/llm-context? (first tool-write)))
-              (is (= [{:role :system :content "Initial context"}
-                      {:role :user :content "Hello"}
-                      {:role :assistant :content "Hi there"}
-                      tool-request]
-                     (get-in (first tool-write) [:frame/data :messages])))
-
-              ;; Verify no message sent to out channel when only tool-call? is true
-              (is (nil? out)))
+            (testing "Handles tool-call request messages correctly"
+              (let [[new-state {:keys [out tool-write sys-out]}]
+                    (sut/context-aggregator-transform
+                      state nil
+                      (frame/llm-context-messages-append
+                        {:messages (conj new-messages tool-request)
+                         :properties {:tool-call? true
+                                      :run-llm? false}}))
+                    [tool-call-request-frame] sys-out]
+
+                ;; Check state update
+                (is (= [{:role :system :content "Initial context"}
+                        {:role :user :content "Hello"}
+                        {:role :assistant :content "Hi there"}
+                        tool-request]
+                       (get-in new-state [:llm/context :messages])))
+
+                ;; Check if message was sent to tool-write channel
+                (is (= 1 (count tool-write)))
+                (is (frame/llm-context? (first tool-write)))
+                (is (= [{:role :system :content "Initial context"}
+                        {:role :user :content "Hello"}
+                        {:role :assistant :content "Hi there"}
+                        tool-request]
+                       (get-in (first tool-write) [:frame/data :messages])))
+
+                ;; Verify no message sent to out channel when only tool-call? is true
+                (is (nil? out))
+                (is (frame/llm-tool-call-request? tool-call-request-frame))
+                (is (= (:frame/data tool-call-request-frame) tool-request))))
 
             ;; Case 3: Append with both tool call and run-llm
             (let [[new-state {:keys [out tool-write]}]