Python: added af_tool bridge for kernel_functions (#13227)

### Motivation and Context

<!-- Thank you for your contribution to the semantic-kernel repo!
Please help reviewers and future users, providing the following
information:
  1. Why is this change required?
  2. What problem does it solve?
  3. What scenario does it contribute to?
  4. If it fixes an open issue, please link to the issue here.
-->
Adds a new method to KernelFunction that creates a Agent Framework Tool
from that function.

Does require the user to install agent-framework-core themselves.

### Description

<!-- Describe your changes, the overall approach, the underlying design.
These notes will help understanding how your code works. Thanks! -->

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [x] The code builds clean without any errors or warnings
- [x] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [x] All unit tests pass, and I have added new tests where possible
- [x] I didn't break anyone 😄

Author: eavanvalkenburg

python/pyproject.toml

@@ -37,7 +37,7 @@ dependencies = [
     "numpy >= 1.25.0; python_version < '3.12'",
     "numpy >= 1.26.0; python_version >= '3.12'",
     # openai connector
-    "openai >= 1.98.0, < 2.0.0",
+    "openai >= 1.98.0,<2",
     # openapi and swagger
     "openapi_core >= 0.18,<0.20",
     "websockets >= 13, < 16",

python/samples/concepts/functions/agent_framework_tools.py

@@ -0,0 +1,72 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import asyncio
+
+from agent_framework.openai import OpenAIResponsesClient
+
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAIChatPromptExecutionSettings
+from semantic_kernel.core_plugins import TimePlugin
+from semantic_kernel.functions import KernelFunctionFromPrompt
+from semantic_kernel.prompt_template import KernelPromptTemplate, PromptTemplateConfig
+
+"""
+This example demonstrates how to create an agent framework tool from a kernel function
+that uses a prompt template with plugin functions. The tool is then used by an Agent
+Framework Agent to answer a question about the current time and date.
+
+
+This sample requires manually installing the `agent-framework-core` package.
+
+```bash
+pip install agent-framework-core --pre
+```
+or with uv:
+```bash
+uv pip install agent-framework-core --prerelease=allow
+```
+"""
+
+
+async def main():
+    kernel = Kernel()
+
+    service_id = "template_language"
+    kernel.add_service(
+        OpenAIChatCompletion(service_id=service_id),
+    )
+
+    kernel.add_plugin(TimePlugin(), "time")
+
+    function_definition = """
+    Today is: {{time.date}}
+    Current time is: {{time.time}}
+
+    Answer to the following questions using JSON syntax, including the data used.
+    Is it morning, afternoon, evening, or night (morning/afternoon/evening/night)?
+    Is it weekend time (weekend/not weekend)?
+    """
+
+    print("--- Rendered Prompt ---")
+    prompt_template_config = PromptTemplateConfig(template=function_definition)
+    prompt_template = KernelPromptTemplate(prompt_template_config=prompt_template_config)
+    rendered_prompt = await prompt_template.render(kernel, arguments=None)
+    print(rendered_prompt)
+
+    function = KernelFunctionFromPrompt(
+        description="Determine the kind of day based on the current time and date.",
+        plugin_name="TimePlugin",
+        prompt_execution_settings=OpenAIChatPromptExecutionSettings(service_id=service_id, max_tokens=100),
+        function_name="kind_of_day",
+        prompt_template=prompt_template,
+    ).as_agent_framework_tool(kernel=kernel)
+
+    print("--- Prompt Function Result ---")
+    response = await (
+        OpenAIResponsesClient(model_id="gpt-5-nano").create_agent(tools=function).run("What kind of day is it?")
+    )
+    print(response.text)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

python/semantic_kernel/connectors/ai/open_ai/services/open_ai_handler.py

@@ -150,7 +150,7 @@ async def _send_image_edit_request(
         try:
             response: ImagesResponse = await self.client.images.edit(
                 image=image,
-                mask=mask,
+                mask=mask,  # type: ignore
                 **settings.prepare_settings_dict(),
             )
             self.store_usage(response)

python/semantic_kernel/functions/kernel_function.py

@@ -11,7 +11,7 @@
 
 from opentelemetry import metrics, trace
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 from semantic_kernel.filters.filter_types import FilterTypes
 from semantic_kernel.filters.functions.function_invocation_context import FunctionInvocationContext
@@ -35,6 +35,9 @@
 from semantic_kernel.utils.telemetry.model_diagnostics import function_tracer
 from semantic_kernel.utils.telemetry.model_diagnostics.gen_ai_attributes import TOOL_CALL_ARGUMENTS, TOOL_CALL_RESULT
 
+from ..contents.chat_message_content import ChatMessageContent
+from ..contents.text_content import TextContent
+
 if TYPE_CHECKING:
     from semantic_kernel.connectors.ai.prompt_execution_settings import PromptExecutionSettings
     from semantic_kernel.contents.streaming_content_mixin import StreamingContentMixin
@@ -405,3 +408,76 @@ def _handle_exception(self, current_span: trace.Span, exception: Exception, attr
         current_span.set_status(trace.StatusCode.ERROR, description=str(exception))
 
         KernelFunctionLogMessages.log_function_error(logger, exception)
+
+    def as_agent_framework_tool(
+        self,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        kernel: "Kernel | None" = None,
+    ) -> Any:
+        """Convert the function to an agent framework tool.
+
+        Args:
+            name: The name of the tool, if None, the function name is used.
+            description: The description of the tool, if None, the tool description is used.
+            kernel: The kernel to use, if None, a kernel is created.
+
+        Returns:
+            AIFunction: The agent framework tool.
+        """
+        import json
+
+        from pydantic import Field, create_model
+
+        from semantic_kernel.kernel import Kernel
+
+        try:
+            from agent_framework import AIFunction
+
+        except ImportError as e:
+            raise ImportError(
+                "agent_framework is not installed. Please install it with 'pip install agent-framework-core'"
+            ) from e
+
+        if not kernel:
+            kernel = Kernel()
+        name = name or self.name
+        description = description or self.description
+        fields = {}
+        for param in self.parameters:
+            if param.include_in_function_choices:
+                if param.default_value is not None:
+                    fields[param.name] = (
+                        param.type_,
+                        Field(description=param.description, default=param.default_value),
+                    )
+                fields[param.name] = (param.type_, Field(description=param.description))
+        input_model = create_model("InputModel", **fields)  # type: ignore
+
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            result = await self.invoke(kernel, *args, **kwargs)
+            if result and result.value is not None:
+                if isinstance(result.value, list):
+                    results: list[Any] = []
+                    for value in result.value:
+                        if isinstance(value, ChatMessageContent):
+                            results.append(str(value))
+                            continue
+                        if isinstance(value, TextContent):
+                            results.append(value.text)
+                            continue
+                        if isinstance(value, BaseModel):
+                            results.append(value.model_dump())
+                            continue
+                        results.append(value)
+                    return json.dumps(results) if len(results) > 1 else json.dumps(results[0])
+                return json.dumps(result.value)
+            return "The function did not return a result."
+
+        return AIFunction(
+            name=name,
+            description=description,
+            input_model=input_model,
+            func=wrapper,
+        )