add kernel function to agent

Author: eavanvalkenburg

python/samples/concepts/agents/chat_completion_agent/chat_completion_function_termination.py

@@ -46,7 +46,7 @@ def get_item_price(
         return "$9.99"
 
 
-def _create_kernel_with_chat_completionand_filter() -> Kernel:
+def _create_kernel_with_chat_completion_and_filter() -> Kernel:
     """A helper function to create a kernel with a chat completion service and a filter."""
     kernel = Kernel()
     kernel.add_service(AzureChatCompletion())
@@ -72,7 +72,7 @@ async def main():
     # 1. Create the agent with a kernel instance that contains
     # the auto function invocation filter and the AI service
     agent = ChatCompletionAgent(
-        kernel=_create_kernel_with_chat_completionand_filter(),
+        kernel=_create_kernel_with_chat_completion_and_filter(),
         name="Host",
         instructions="Answer questions about the menu.",
     )

python/samples/concepts/auto_function_calling/chat_completion_with_agent_as_function.py

@@ -0,0 +1,180 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+
+from samples.concepts.setup.chat_completion_services import Services, get_chat_completion_service_and_request_settings
+from semantic_kernel import Kernel
+from semantic_kernel.agents.chat_completion.chat_completion_agent import ChatCompletionAgent
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from semantic_kernel.contents import ChatHistory
+from semantic_kernel.filters.functions.function_invocation_context import FunctionInvocationContext
+
+"""
+This sample demonstrates how to build a conversational chatbot
+using Semantic Kernel, featuring auto function calling,
+using agents as functions, this includes letting a chat interaction
+call an agent, and giving one agent another agent to do things.
+"""
+
+# System message defining the behavior and persona of the chat bot.
+system_message = """
+You are a chat bot. Your name is Mosscap and
+you have one goal: figure out what people need.
+Your full name, should you need to know it, is
+Splendid Speckled Mosscap. You communicate
+effectively, but you tend to answer with long
+flowery prose. You are also a math wizard,
+especially for adding and subtracting.
+You also excel at joke telling, where your tone is often sarcastic.
+Once you have the answer I am looking for,
+you will return a full answer to me as soon as possible.
+"""
+
+
+# Define the auto function invocation filter that will be used by the kernel
+async def function_invocation_filter(context: FunctionInvocationContext, next):
+    """A filter that will be called for each function call in the response."""
+    if "task" not in context.arguments:
+        await next(context)
+        return
+    print(f"    Agent {context.function.name} called with task: {context.arguments['task']}")
+    await next(context)
+    print(f"    Response from agent {context.function.name}: {context.result.value}")
+
+
+# Create and configure the kernel.
+kernel = Kernel()
+kernel.add_filter("function_invocation", function_invocation_filter)
+
+# You can select from the following chat completion services that support function calling:
+# - Services.OPENAI
+# - Services.AZURE_OPENAI
+# - Services.AZURE_AI_INFERENCE
+# - Services.ANTHROPIC
+# - Services.BEDROCK
+# - Services.GOOGLE_AI
+# - Services.MISTRAL_AI
+# - Services.OLLAMA
+# - Services.ONNX
+# - Services.VERTEX_AI
+# - Services.DEEPSEEK
+# Please make sure you have configured your environment correctly for the selected chat completion service.
+chat_completion_service, request_settings = get_chat_completion_service_and_request_settings(Services.OPENAI)
+
+# Configure the function choice behavior. Here, we set it to Auto, where auto_invoke=True by default.
+# With `auto_invoke=True`, the model will automatically choose and call functions as needed.
+request_settings.function_choice_behavior = FunctionChoiceBehavior.Auto(filters={"excluded_plugins": ["ChatBot"]})
+
+# Create a chat history to store the system message, initial messages, and the conversation.
+history = ChatHistory()
+history.add_system_message(system_message)
+
+REVIEWER_NAME = "ArtDirector"
+REVIEWER_INSTRUCTIONS = """
+You are an art director who has opinions about copywriting born of a love for David Ogilvy.
+You ask one of the copy-writing agents for a piece of copy, which you then review.
+The goal is to determine if the given copy is acceptable to print.
+If so, respond with the created copy.
+If not, do not return, but ask a copywriter again for copy, providing the returned copy and feedback.
+"""
+
+COPYWRITER_NAME = "CopyWriter"
+COPYWRITER_INSTRUCTIONS = """
+You are a copywriter with ten years of experience and are known for brevity and a dry humor.
+The goal is to refine and decide on the single best copy as an expert in the field.
+Only provide a single proposal per response.
+You're laser focused on the goal at hand.
+Don't waste time with chit chat.
+Consider suggestions when refining an idea.
+"""
+
+writer_agent = ChatCompletionAgent(
+    service=chat_completion_service,
+    name=COPYWRITER_NAME,
+    description="This agent can write copy about any topic.",
+    instructions=COPYWRITER_INSTRUCTIONS,
+)
+reviewer_agent = ChatCompletionAgent(
+    service=chat_completion_service,
+    name=REVIEWER_NAME,
+    description="This agent can review copy and provide feedback, he does has copy writers available.",
+    instructions=REVIEWER_INSTRUCTIONS,
+    plugins=[writer_agent],
+)
+
+reviewer_agent.kernel.add_filter("function_invocation", function_invocation_filter)
+
+kernel.add_plugins([reviewer_agent])
+
+
+async def chat() -> bool:
+    """
+    Continuously prompt the user for input and show the assistant's response.
+    Type 'exit' to exit.
+    """
+    try:
+        user_input = input("User:> ")
+    except (KeyboardInterrupt, EOFError):
+        print("\n\nExiting chat...")
+        return False
+
+    if user_input.lower().strip() == "exit":
+        print("\n\nExiting chat...")
+        return False
+    history.add_user_message(user_input)
+    # Handle non-streaming responses
+    result = await chat_completion_service.get_chat_message_content(
+        chat_history=history, settings=request_settings, kernel=kernel
+    )
+
+    # Update the chat history with the user's input and the assistant's response
+    if result:
+        print(f"Mosscap:> {result}")
+        history.add_message(result)
+
+    return True
+
+
+"""
+Sample output:
+Welcome to the chat bot!
+  Type 'exit' to exit.
+  Try to get some copy written by the copy writer, make sure to ask it is reviewed.).
+User:> write a slogan for electric vehicles
+Mosscap:> Ah, the realm of electric vehicles, where the whispers of sustainability dance with the vibrant hum of 
+innovation! How about this for a slogan: 
+
+"Drive the Future: Silent, Smart, and Sustainable!" 
+
+This phrase encapsulates the essence of electric vehicles, inviting all to embrace a journey that is not only 
+forward-thinking but also harmoniously aligned with the gentle rhythms of our planet. Would you like to explore 
+more options or perhaps delve into another aspect of this electrifying topic?
+User:> ask the art director for it
+    Agent ArtDirector called with task: Create a slogan for electric vehicles that captures their innovative and 
+    sustainable essence.
+    Agent CopyWriter called with task: Create a slogan for electric vehicles that captures their innovative and 
+    sustainable essence.
+    Response from agent CopyWriter: "Drive the Future: Silent, Smart, Sustainable."
+    Response from agent ArtDirector: "Drive the Future: Silent, Smart, Sustainable."
+Mosscap:> The Art Director has conjured forth a splendid slogan for electric vehicles: 
+
+"Drive the Future: Silent, Smart, Sustainable."
+
+This phrase beautifully encapsulates the innovative spirit and eco-friendly nature of electric vehicles. 
+If you seek further refinement or wish to explore additional ideas, simply let me know, and I shall be at your service!
+"""
+
+
+async def main() -> None:
+    print(
+        "Welcome to the chat bot!\n"
+        "  Type 'exit' to exit.\n"
+        "  Try to get some copy written by the copy writer, make sure to ask it is reviewed.)."
+    )
+    chatting = True
+    while chatting:
+        chatting = await chat()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/samples/concepts/auto_function_calling/chat_completion_with_manual_function_calling.py

@@ -1,7 +1,6 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 import asyncio
-from typing import TYPE_CHECKING
 
 from samples.concepts.setup.chat_completion_services import Services, get_chat_completion_service_and_request_settings
 from semantic_kernel import Kernel
@@ -13,9 +12,6 @@
 from semantic_kernel.core_plugins.time_plugin import TimePlugin
 from semantic_kernel.functions import KernelArguments
 
-if TYPE_CHECKING:
-    pass
-
 #####################################################################
 # This sample demonstrates how to build a conversational chatbot    #
 # using Semantic Kernel, featuring manual function calling,         #

python/semantic_kernel/agents/agent.py

@@ -4,14 +4,16 @@
 import uuid
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterable, Iterable
-from typing import Any, ClassVar
+from typing import Annotated, Any, ClassVar
 
 from pydantic import Field, model_validator
 
 from semantic_kernel.agents.channels.agent_channel import AgentChannel
+from semantic_kernel.contents.chat_history import ChatHistory
 from semantic_kernel.contents.chat_message_content import ChatMessageContent
 from semantic_kernel.contents.streaming_chat_message_content import StreamingChatMessageContent
 from semantic_kernel.functions.kernel_arguments import KernelArguments
+from semantic_kernel.functions.kernel_function_decorator import kernel_function
 from semantic_kernel.functions.kernel_plugin import KernelPlugin
 from semantic_kernel.kernel import Kernel
 from semantic_kernel.kernel_pydantic import KernelBaseModel
@@ -56,9 +58,7 @@ class Agent(KernelBaseModel, ABC):
     @staticmethod
     def _get_plugin_name(plugin: KernelPlugin | object) -> str:
         """Helper method to get the plugin name."""
-        if isinstance(plugin, KernelPlugin):
-            return plugin.name
-        return plugin.__class__.__name__
+        return getattr(plugin, "name", plugin.__class__.__name__)
 
     @model_validator(mode="before")
     @classmethod
@@ -74,6 +74,19 @@ def _configure_plugins(cls, data: Any) -> Any:
             data["kernel"] = kernel
         return data
 
+    def model_post_init(self, __context: Any) -> None:
+        """Post initialization."""
+
+        @kernel_function(name=self.name, description=self.description)
+        async def _invoke_agent_as_function_inner(
+            task: Annotated[str, "The task to perform."],
+        ) -> Annotated[str, "The response from the agent."]:
+            history = ChatHistory()
+            history.add_user_message(task)
+            return (await self.get_response(history=history)).content
+
+        setattr(self, "_as_function", _invoke_agent_as_function_inner)
+
     @abstractmethod
     async def get_response(self, *args, **kwargs) -> ChatMessageContent:
         """Get a response from the agent.

python/semantic_kernel/functions/kernel_function_extension.py

@@ -85,7 +85,7 @@ def add_plugin(
             self.plugins[plugin.name] = plugin
             return self.plugins[plugin.name]
         if not plugin_name:
-            raise ValueError("plugin_name must be provided if a plugin is not supplied.")
+            plugin_name = plugin.name if hasattr(plugin, "name") else plugin.__class__.__name__
         if not isinstance(plugin_name, str):
             raise TypeError("plugin_name must be a string.")
         if plugin:
@@ -103,7 +103,7 @@ def add_plugin(
             return self.plugins[plugin_name]
         raise ValueError("plugin or parent_directory must be provided.")
 
-    def add_plugins(self, plugins: list[KernelPlugin] | dict[str, KernelPlugin | object]) -> None:
+    def add_plugins(self, plugins: list[KernelPlugin | object] | dict[str, KernelPlugin | object]) -> None:
         """Adds a list of plugins to the kernel's collection of plugins.
 
         Args:

python/semantic_kernel/functions/kernel_plugin.py

@@ -238,6 +238,7 @@ def from_object(
             candidates = plugin_instance.items()
         else:
             candidates = inspect.getmembers(plugin_instance, inspect.ismethod)
+            candidates.extend(inspect.getmembers(plugin_instance, inspect.isfunction))  # type: ignore
         # Read every method from the plugin instance
         functions = [
             KernelFunctionFromMethod(method=candidate, plugin_name=plugin_name)