nvidia-nat-semantic-kernel 1.4.0a20251122__py3-none-any.whl

nat/meta/pypi.md

@@ -0,0 +1,23 @@
+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+![NVIDIA NeMo Agent Toolkit](https://media.githubusercontent.com/media/NVIDIA/NeMo-Agent-Toolkit/refs/heads/main/docs/source/_static/banner.png "NeMo Agent toolkit banner image")
+
+# NVIDIA NeMo Agent Toolkit Subpackage
+This is a subpackage for Semantic-Kernel integration in NeMo Agent toolkit.
+
+For more information about the NVIDIA NeMo Agent toolkit, please visit the [NeMo Agent toolkit GitHub Repo](https://github.com/NVIDIA/NeMo-Agent-Toolkit).

nat/plugins/semantic_kernel/llm.py

@@ -0,0 +1,115 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import TypeVar
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.cli.register_workflow import register_llm_client
+from nat.data_models.common import get_secret_value
+from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.retry_mixin import RetryMixin
+from nat.data_models.thinking_mixin import ThinkingMixin
+from nat.llm.azure_openai_llm import AzureOpenAIModelConfig
+from nat.llm.openai_llm import OpenAIModelConfig
+from nat.llm.utils.thinking import BaseThinkingInjector
+from nat.llm.utils.thinking import FunctionArgumentWrapper
+from nat.llm.utils.thinking import patch_with_thinking
+from nat.utils.exception_handlers.automatic_retries import patch_with_retry
+from nat.utils.responses_api import validate_no_responses_api
+from nat.utils.type_utils import override
+
+ModelType = TypeVar("ModelType")
+
+
+def _patch_llm_based_on_config(client: ModelType, llm_config: LLMBaseConfig) -> ModelType:
+
+    from semantic_kernel.contents.chat_history import ChatHistory
+
+    class SemanticKernelThinkingInjector(BaseThinkingInjector):
+
+        @override
+        def inject(self, chat_history: ChatHistory, *args, **kwargs) -> FunctionArgumentWrapper:
+            """
+            Inject a system prompt into the chat_history.
+
+            The chat_history is the first (non-object) argument to the function.
+            The rest of the arguments are passed through unchanged.
+
+            Args:
+                chat_history: The ChatHistory object to inject the system prompt into.
+                *args: The rest of the arguments to the function.
+                **kwargs: The rest of the keyword arguments to the function.
+
+            Returns:
+                FunctionArgumentWrapper: An object that contains the transformed args and kwargs.
+            """
+            if chat_history.system_message is None:
+                new_messages = ChatHistory(chat_history.messages, system_message=self.system_prompt)
+                return FunctionArgumentWrapper(new_messages, *args, **kwargs)
+            else:
+                new_messages = ChatHistory(
+                    chat_history.messages,
+                    system_message=f"{self.system_prompt}\n\n{chat_history.system_message}",
+                )
+                return FunctionArgumentWrapper(new_messages, *args, **kwargs)
+
+    if isinstance(llm_config, RetryMixin):
+        client = patch_with_retry(client,
+                                  retries=llm_config.num_retries,
+                                  retry_codes=llm_config.retry_on_status_codes,
+                                  retry_on_messages=llm_config.retry_on_errors)
+
+    if isinstance(llm_config, ThinkingMixin) and llm_config.thinking_system_prompt is not None:
+        client = patch_with_thinking(
+            client,
+            SemanticKernelThinkingInjector(
+                system_prompt=llm_config.thinking_system_prompt,
+                function_names=[
+                    "get_chat_message_contents",
+                    "get_streaming_chat_message_contents",
+                ],
+            ))
+
+    return client
+
+
+@register_llm_client(config_type=AzureOpenAIModelConfig, wrapper_type=LLMFrameworkEnum.SEMANTIC_KERNEL)
+async def azure_openai_semantic_kernel(llm_config: AzureOpenAIModelConfig, _builder: Builder):
+
+    from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
+
+    validate_no_responses_api(llm_config, LLMFrameworkEnum.SEMANTIC_KERNEL)
+
+    llm = AzureChatCompletion(
+        api_key=get_secret_value(llm_config.api_key),
+        api_version=llm_config.api_version,
+        endpoint=llm_config.azure_endpoint,
+        deployment_name=llm_config.azure_deployment,
+    )
+
+    yield _patch_llm_based_on_config(llm, llm_config)
+
+
+@register_llm_client(config_type=OpenAIModelConfig, wrapper_type=LLMFrameworkEnum.SEMANTIC_KERNEL)
+async def openai_semantic_kernel(llm_config: OpenAIModelConfig, _builder: Builder):
+
+    from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
+
+    validate_no_responses_api(llm_config, LLMFrameworkEnum.SEMANTIC_KERNEL)
+
+    llm = OpenAIChatCompletion(ai_model_id=llm_config.model_name)
+
+    yield _patch_llm_based_on_config(llm, llm_config)

nat/plugins/semantic_kernel/register.py

@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# flake8: noqa
+# isort:skip_file
+
+# Import any providers which need to be automatically registered here
+
+from . import llm
+from . import tool_wrapper

nat/plugins/semantic_kernel/tool_wrapper.py

@@ -0,0 +1,161 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import types
+from collections.abc import Callable
+from dataclasses import is_dataclass
+from typing import Any
+from typing import Union
+from typing import get_args
+from typing import get_origin
+
+from pydantic import BaseModel
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function import Function
+from nat.cli.register_workflow import register_tool_wrapper
+
+logger = logging.getLogger(__name__)
+
+
+def get_type_info(field_type):
+    origin = get_origin(field_type)
+    if origin is None:
+        # It’s a simple type
+        return getattr(field_type, "__name__", str(field_type))
+
+    # Handle Union types specially
+    if origin in (Union, types.UnionType):
+        # Pick the first type that isn’t NoneType
+        non_none = [arg for arg in get_args(field_type) if arg is not type(None)]
+        if non_none:
+            return getattr(non_none[0], "__name__", str(non_none[0]))
+
+        return 'str'  # fallback if union is only str (unlikely)
+
+    # For other generics, capture both the origin and its parameters
+    return getattr(origin, "__name__", str(origin))
+
+
+def resolve_type(t):
+    origin = get_origin(t)
+    if origin in (Union, types.UnionType):
+        # Pick the first type that isn’t NoneType
+        for arg in get_args(t):
+            if arg is not None:
+                return arg
+
+        return t  # fallback if union is only NoneType (unlikely)
+    return t
+
+
+@register_tool_wrapper(wrapper_type=LLMFrameworkEnum.SEMANTIC_KERNEL)
+def semantic_kernel_tool_wrapper(name: str, fn: Function, builder: Builder):
+
+    async def callable_ainvoke(*args, **kwargs):
+        return await fn.acall_invoke(*args, **kwargs)
+
+    async def callable_astream(*args, **kwargs):
+        async for item in fn.acall_stream(*args, **kwargs):
+            yield item
+
+    def nat_kernel_function(
+        func: Callable[..., object] | None = None,
+        nat_function: Function | None = None,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Callable[..., Any]:
+        """
+        Modified version of Semantic Kernel's kernel_function decorator.
+
+        Uses `nat` Function properties instead of doing type inference on the function's inner
+        """
+
+        def decorator(func: Callable[..., object]) -> Callable[..., object]:
+            """The actual decorator function."""
+            setattr(func, "__kernel_function__", True)
+            setattr(func, "__kernel_function_description__", description or nat_function.description)
+            setattr(func, "__kernel_function_name__", name or nat_function.config.type)
+
+            # Always defer to single output schema, if present, for now
+            # No need to check streaming output is present given one of the two is always present
+            has_single = nat_function.has_single_output
+            has_streaming = nat_function.has_streaming_output
+            output_schema = nat_function.single_output_schema if has_single else nat_function.streaming_output_schema
+            setattr(func, "__kernel_function_streaming__", not nat_function.has_single_output if has_single else True)
+
+            if has_single and has_streaming:
+                logger.warning("Function has both single and streaming output schemas. "
+                               "Defaulting to single output schema.")
+
+            input_annotations = []
+            for arg_name, annotation in nat_function.input_schema.model_fields.items():
+                type_obj = resolve_type(annotation.annotation)
+                include_in_choices = True
+                if isinstance(type_obj, type) and (issubclass(type_obj, BaseModel) or is_dataclass(type_obj)):
+                    logger.warning(
+                        "Nested non-native model detected in input schema for parameter: %s. "
+                        "Setting include_in_function_choices to False.",
+                        arg_name)
+                    # Don't error out here
+                    # Just instead avoid showing the tool to the model
+                    include_in_choices = False
+                input_annotations.append({
+                    "is_required": annotation.is_required(),
+                    "name": arg_name,
+                    "type_": get_type_info(annotation.annotation),
+                    "type_object": type_obj,
+                    "include_in_function_choices": include_in_choices
+                })
+
+            setattr(func, "__kernel_function_parameters__", input_annotations)
+
+            return_annotations = []
+            for arg_name, annotation in output_schema.model_fields.items():
+                type_obj = resolve_type(annotation.annotation)
+                include_in_choices = True
+                if isinstance(type_obj, type) and (issubclass(type_obj, BaseModel) or is_dataclass(type_obj)):
+                    logger.warning(
+                        "Nested non-native model detected in output schema for parameter: %s. "
+                        "Setting include_in_function_choices to False.",
+                        arg_name)
+                    include_in_choices = False
+                return_annotations.append({
+                    "is_required": annotation.is_required(),
+                    "name": arg_name,
+                    "type_": get_type_info(annotation.annotation),
+                    "type_object": type_obj,
+                    "include_in_function_choices": include_in_choices
+                })
+            return_annotation = return_annotations[0]
+
+            setattr(func, "__kernel_function_return_type__", return_annotation.get("type_", "None"))
+            setattr(func, "__kernel_function_return_type_object__", return_annotation.get("type_object", None))
+            setattr(func, "__kernel_function_return_description__", return_annotation.get("description", ""))
+            setattr(func, "__kernel_function_return_required__", return_annotation.get("is_required", False))
+            return func
+
+        if func:
+            return decorator(func)
+        return decorator
+
+    if fn.has_streaming_output and not fn.has_single_output:
+        kernel_func = nat_kernel_function(func=callable_astream, nat_function=fn, name=name, description=fn.description)
+    else:
+        kernel_func = nat_kernel_function(func=callable_ainvoke, nat_function=fn, name=name, description=fn.description)
+
+    return {name: kernel_func}

nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-semantic-kernel
+Version: 1.4.0a20251122
+Summary: Subpackage for Semantic-Kernel integration in NeMo Agent toolkit
+Author: NVIDIA Corporation
+Maintainer: NVIDIA Corporation
+License: Apache-2.0
+Project-URL: documentation, https://docs.nvidia.com/nemo/agent-toolkit/latest/
+Project-URL: source, https://github.com/NVIDIA/NeMo-Agent-Toolkit
+Keywords: ai,rag,agents
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE-3rd-party.txt
+License-File: LICENSE.md
+Requires-Dist: nvidia-nat==v1.4.0a20251122
+Requires-Dist: semantic-kernel~=1.35
+Dynamic: license-file
+
+<!--
+SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+![NVIDIA NeMo Agent Toolkit](https://media.githubusercontent.com/media/NVIDIA/NeMo-Agent-Toolkit/refs/heads/main/docs/source/_static/banner.png "NeMo Agent toolkit banner image")
+
+# NVIDIA NeMo Agent Toolkit Subpackage
+This is a subpackage for Semantic-Kernel integration in NeMo Agent toolkit.
+
+For more information about the NVIDIA NeMo Agent toolkit, please visit the [NeMo Agent toolkit GitHub Repo](https://github.com/NVIDIA/NeMo-Agent-Toolkit).

nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/RECORD

@@ -0,0 +1,12 @@
+nat/meta/pypi.md,sha256=rFmwVds3akmoz0TE1SOjCjCUbB6SWfaRex_Vi5OfUAk,1116
+nat/plugins/semantic_kernel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nat/plugins/semantic_kernel/llm.py,sha256=nuadrIqpc4SXQT6EWii8M7I6_cCZR0qPArZtfnpKUGo,4908
+nat/plugins/semantic_kernel/register.py,sha256=_R3bhGmz___696_NwyIcpw3koMBiWqIFoWEFJ0VAgXs,831
+nat/plugins/semantic_kernel/tool_wrapper.py,sha256=N6WGEdveLYFKtOKjxEMMNT5vG8QJUoSddtswQ1fPEzQ,7121
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/METADATA,sha256=44zL_FgBnbAGMEQrqfZ4mXMWbQTvAFWWbat24K9t9N8,1946
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/entry_points.txt,sha256=0jCtQBAn5Ohs9XoVCF34WvNCV33OwAsH8bjFzgw_ByM,76
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/RECORD,,

nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nvidia_nat_semantic_kernel-1.4.0a20251122.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[nat.components]
+nat_semantic_kernel = nat.plugins.semantic_kernel.register