Avoid notify thread when auto-invoke is not active

Author: Milder Hernandez Cagua

agents/semantickernel-agents-core/src/main/java/com/microsoft/semantickernel/agents/chatcompletion/ChatCompletionAgent.java

@@ -6,10 +6,10 @@
 import com.microsoft.semantickernel.agents.AgentThread;
 import com.microsoft.semantickernel.agents.KernelAgent;
 import com.microsoft.semantickernel.builders.SemanticKernelBuilder;
+import com.microsoft.semantickernel.functionchoice.AutoFunctionChoiceBehavior;
 import com.microsoft.semantickernel.orchestration.InvocationContext;
 import com.microsoft.semantickernel.orchestration.InvocationReturnMode;
 import com.microsoft.semantickernel.orchestration.PromptExecutionSettings;
-import com.microsoft.semantickernel.orchestration.ToolCallBehavior;
 import com.microsoft.semantickernel.semanticfunctions.KernelArguments;
 import com.microsoft.semantickernel.semanticfunctions.PromptTemplate;
 import com.microsoft.semantickernel.semanticfunctions.PromptTemplateConfig;
@@ -76,22 +76,20 @@ public Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(
                     // Invoke the agent with the chat history
                     return internalInvokeAsync(
                             history,
+                            agentThread,
                             options
                     )
-                    .flatMapMany(Flux::fromIterable)
-                    // notify on the new thread instance
-                    .concatMap(agentMessage -> this.notifyThreadOfNewMessageAsync(agentThread, agentMessage).thenReturn(agentMessage))
-                    .collectList()
                     .map(chatMessageContents ->
                             chatMessageContents.stream()
-                                    .map(message -> new AgentResponseItem<ChatMessageContent<?>>(message, agentThread))
-                                    .collect(Collectors.toList())
+                            .map(message -> new AgentResponseItem<ChatMessageContent<?>>(message, agentThread))
+                            .collect(Collectors.toList())
                     );
                 });
     }
 
     private Mono<List<ChatMessageContent<?>>> internalInvokeAsync(
         ChatHistory history,
+        AgentThread thread,
         @Nullable AgentInvokeOptions options
     ) {
         if (options == null) {
@@ -144,6 +142,20 @@ private Mono<List<ChatMessageContent<?>>> internalInvokeAsync(
                     // Add the chat history to the new chat
                     chat.addAll(history);
 
+                    // Retrieve the chat message contents asynchronously and notify the thread
+                    if (shouldNotifyFunctionCalls(agentInvocationContext)) {
+                        // Notify all messages including function calls
+                        return chatCompletionService.getChatMessageContentsAsync(chat, kernel, agentInvocationContext)
+                            .flatMapMany(Flux::fromIterable)
+                            .concatMap(message -> notifyThreadOfNewMessageAsync(thread, message).thenReturn(message))
+                            // Filter out function calls and their results
+                            .filter(message -> message.getContent() != null && message.getAuthorRole() != AuthorRole.TOOL)
+                            .collect(Collectors.toList());
+                    }
+
+                    // Return chat completion messages without notifying the thread
+                    // We shouldn't add the function call content to the thread, since
+                    // we don't know if the user will execute the call. They should add it themselves.
                     return chatCompletionService.getChatMessageContentsAsync(chat, kernel, agentInvocationContext);
                 }
             );
@@ -153,6 +165,22 @@ private Mono<List<ChatMessageContent<?>>> internalInvokeAsync(
         }
     }
 
+    boolean shouldNotifyFunctionCalls(InvocationContext invocationContext) {
+        if (invocationContext == null) {
+            return false;
+        }
+
+        if (invocationContext.getFunctionChoiceBehavior() != null && invocationContext.getFunctionChoiceBehavior() instanceof AutoFunctionChoiceBehavior) {
+            return ((AutoFunctionChoiceBehavior) invocationContext.getFunctionChoiceBehavior()).isAutoInvoke();
+        }
+
+        if (invocationContext.getToolCallBehavior() != null) {
+            return invocationContext.getToolCallBehavior().isAutoInvokeAllowed();
+        }
+
+        return false;
+    }
+
 
     @Override
     public Mono<Void> notifyThreadOfNewMessageAsync(AgentThread thread, ChatMessageContent<?> message) {

samples/semantickernel-concepts/semantickernel-syntax-examples/src/main/java/com/microsoft/semantickernel/samples/syntaxexamples/agents/CompletionAgent.java

@@ -6,14 +6,17 @@
 import com.azure.core.credential.KeyCredential;
 import com.microsoft.semantickernel.Kernel;
 import com.microsoft.semantickernel.agents.AgentInvokeOptions;
+import com.microsoft.semantickernel.agents.AgentThread;
 import com.microsoft.semantickernel.agents.chatcompletion.ChatCompletionAgent;
 import com.microsoft.semantickernel.agents.chatcompletion.ChatHistoryAgentThread;
 import com.microsoft.semantickernel.aiservices.openai.chatcompletion.OpenAIChatCompletion;
 import com.microsoft.semantickernel.contextvariables.ContextVariableTypeConverter;
+import com.microsoft.semantickernel.contextvariables.ContextVariableTypes;
 import com.microsoft.semantickernel.functionchoice.FunctionChoiceBehavior;
 import com.microsoft.semantickernel.implementation.templateengine.tokenizer.DefaultPromptTemplate;
 import com.microsoft.semantickernel.orchestration.InvocationContext;
 import com.microsoft.semantickernel.orchestration.PromptExecutionSettings;
+import com.microsoft.semantickernel.orchestration.ToolCallBehavior;
 import com.microsoft.semantickernel.plugin.KernelPluginFactory;
 import com.microsoft.semantickernel.samples.plugins.github.GitHubModel;
 import com.microsoft.semantickernel.samples.plugins.github.GitHubPlugin;
@@ -105,7 +108,7 @@ public static void main(String[] args) {
                     )
                 ).build();
 
-        ChatHistoryAgentThread agentThread = new ChatHistoryAgentThread();
+        AgentThread agentThread = new ChatHistoryAgentThread();
         Scanner scanner = new Scanner(System.in);
 
         while (true) {
@@ -118,22 +121,19 @@ public static void main(String[] args) {
 
             var message = new ChatMessageContent<>(AuthorRole.USER, input);
             KernelArguments arguments = KernelArguments.builder()
-                    .withVariable("now", System.currentTimeMillis())
-                    .build();
+                .withVariable("now", System.currentTimeMillis())
+                .build();
 
             var response = agent.invokeAsync(
-                    List.of(message),
-                    agentThread,
-                    AgentInvokeOptions.builder()
-                            .withKernel(kernel)
-                            .withKernelArguments(arguments)
-                            .build()
-            ).block();
-
-            var lastResponse = response.get(response.size() - 1);
+                message,
+                agentThread,
+                AgentInvokeOptions.builder()
+                        .withKernelArguments(arguments)
+                        .build()
+            ).block().get(0);
 
-            System.out.println("> " + lastResponse.getMessage());
-            agentThread = (ChatHistoryAgentThread) lastResponse.getThread();
+            System.out.println("> " + response.getMessage());
+            agentThread = response.getThread();
         }
     }
 }

semantickernel-api/src/main/java/com/microsoft/semantickernel/agents/Agent.java

@@ -43,6 +43,33 @@ public interface Agent {
      */
     String getDescription();
 
+    /**
+     * Invokes the agent with the given message.
+     *
+     * @param message The message to process
+     * @return A Mono containing the agent response
+     */
+    Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(ChatMessageContent<?> message);
+
+    /**
+     * Invokes the agent with the given message and thread.
+     *
+     * @param message The message to process
+     * @param thread The agent thread to use
+     * @return A Mono containing the agent response
+     */
+    Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(ChatMessageContent<?> message, AgentThread thread);
+
+    /**
+     * Invokes the agent with the given message, thread, and options.
+     *
+     * @param message The message to process
+     * @param thread The agent thread to use
+     * @param options The options for invoking the agent
+     * @return A Mono containing the agent response
+     */
+    Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(ChatMessageContent<?> message, AgentThread thread, AgentInvokeOptions options);
+
     /**
      * Invoke the agent with the given chat history.
      *

semantickernel-api/src/main/java/com/microsoft/semantickernel/agents/AgentInvokeOptions.java

@@ -13,9 +13,13 @@
  */
 public class AgentInvokeOptions {
 
+    @Nullable
     private final KernelArguments kernelArguments;
+    @Nullable
     private final Kernel kernel;
+    @Nullable
     private final String additionalInstructions;
+    @Nullable
     private final InvocationContext invocationContext;
 
     /**

semantickernel-api/src/main/java/com/microsoft/semantickernel/agents/KernelAgent.java

@@ -11,6 +11,7 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -114,7 +115,6 @@ public PromptTemplate getTemplate() {
         return template;
     }
 
-
     /**
      * Merges the provided arguments with the current arguments.
      * Provided arguments will override the current arguments.
@@ -167,4 +167,21 @@ protected <T extends AgentThread> Mono<T> ensureThreadExistsWithMessagesAsync(Li
                     .then(Mono.just((T) newThread));
         });
     }
+
+    @Override
+    public Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(ChatMessageContent<?> message) {
+        return invokeAsync(message, null);
+    }
+
+    @Override
+    public Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(ChatMessageContent<?> message, AgentThread thread) {
+        return invokeAsync(message, thread, AgentInvokeOptions.builder().build());
+    }
+
+    @Override
+    public Mono<List<AgentResponseItem<ChatMessageContent<?>>>> invokeAsync(ChatMessageContent<?> message, AgentThread thread, AgentInvokeOptions options) {
+        ArrayList<ChatMessageContent<?>> messages = new ArrayList<>();
+        messages.add(message);
+        return invokeAsync(messages, thread, options);
+    }
 }