nvidia-nat-adk 1.1.0a20251020__py3-none-any.whl

nat/meta/pypi.md

@@ -0,0 +1,21 @@
+<!--
+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://raw.githubusercontent.com/NVIDIA/NeMo-Agent-Toolkit/main/docs/source/_static/banner.png "NeMo Agent Toolkit banner")
+
+# NVIDIA NeMo Agent Toolkit — Google ADK Subpackage
+Subpackage providing Google ADK integration for the NVIDIA NeMo Agent Toolkit.

nat/plugins/adk/__init__.py

@@ -0,0 +1,14 @@
+# 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.

nat/plugins/adk/adk_callback_handler.py

@@ -0,0 +1,308 @@
+# 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 copy
+import logging
+import threading
+import time
+from collections.abc import Callable
+from typing import Any
+
+from nat.builder.context import Context
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.data_models.intermediate_step import IntermediateStepPayload
+from nat.data_models.intermediate_step import IntermediateStepType
+from nat.data_models.intermediate_step import StreamEventData
+from nat.data_models.intermediate_step import TraceMetadata
+from nat.data_models.intermediate_step import UsageInfo
+from nat.profiler.callbacks.base_callback_class import BaseProfilerCallback
+from nat.profiler.callbacks.token_usage_base_model import TokenUsageBaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class ADKProfilerHandler(BaseProfilerCallback):
+    """
+    A callback manager/handler for Google ADK that intercepts calls to:
+      - Tools
+      - LLMs
+
+    to collect usage statistics (tokens, inputs, outputs, time intervals, etc.)
+    and store them in NeMo Agent Toolkit's usage_stats queue for subsequent analysis.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._lock = threading.Lock()
+        self.last_call_ts = time.time()
+        self.step_manager = Context.get().intermediate_step_manager
+
+        # Original references to Google ADK Tool and LLM methods (for uninstrumenting if needed)
+        self._original_tool_call = None
+        self._original_llm_call = None
+        self._instrumented = False
+
+    def instrument(self) -> None:
+        """
+        Monkey-patch the relevant Google ADK methods with usage-stat collection logic.
+        Assumes the 'google-adk' library is installed.
+        """
+        import litellm
+
+        if getattr(self, "_instrumented", False):
+            logger.debug("ADKProfilerHandler already instrumented; skipping.")
+            return
+        try:
+            from google.adk.tools.function_tool import FunctionTool
+        except Exception as _e:
+            logger.exception("ADK import failed; skipping instrumentation")
+            return
+
+        # Save the originals
+        self._original_tool_call = getattr(FunctionTool, "run_async", None)
+        self._original_llm_call = getattr(litellm, "acompletion", None)
+
+        # Patch if available
+        if self._original_tool_call:
+            FunctionTool.run_async = self._tool_use_monkey_patch()
+
+        if self._original_llm_call:
+            litellm.acompletion = self._llm_call_monkey_patch()
+
+        logger.debug("ADKProfilerHandler instrumentation applied successfully.")
+        self._instrumented = True
+
+    def uninstrument(self) -> None:
+        """ Restore the original Google ADK methods.
+        Add an explicit unpatch to avoid side-effects across tests/process lifetime.
+        """
+        try:
+            import litellm
+            from google.adk.tools.function_tool import FunctionTool
+            if self._original_tool_call:
+                FunctionTool.run_async = self._original_tool_call
+            if self._original_llm_call:
+                litellm.acompletion = self._original_llm_call
+            logger.debug("ADKProfilerHandler uninstrumented successfully.")
+        except Exception as _e:
+            logger.exception("Failed to uninstrument ADKProfilerHandler")
+
+    def _tool_use_monkey_patch(self) -> Callable[..., Any]:
+        """
+        Returns a function that wraps calls to BaseTool.run_async with usage-logging.
+        """
+        original_func = self._original_tool_call
+
+        async def wrapped_tool_use(base_tool_instance, *args, **kwargs) -> Any:
+            """
+            Replicates _tool_use_wrapper logic without wrapt: collects usage stats,
+            calls the original, and captures output stats.
+
+            Args:
+                base_tool_instance (FunctionTool): The instance of the tool being called.
+                *args: Positional arguments to the tool.
+                **kwargs: Keyword arguments to the tool.
+
+            Returns:
+                Any: The result of the tool execution.
+            """
+            now = time.time()
+            tool_name = ""
+
+            try:
+                tool_name = base_tool_instance.name
+            except Exception as _e:
+                logger.exception("Error getting tool name")
+                tool_name = ""
+
+            try:
+                # Pre-call usage event - safely extract kwargs args if present
+                kwargs_args = (kwargs.get("args", {}) if isinstance(kwargs.get("args"), dict) else {})
+                stats = IntermediateStepPayload(
+                    event_type=IntermediateStepType.TOOL_START,
+                    framework=LLMFrameworkEnum.ADK,
+                    name=tool_name,
+                    data=StreamEventData(),
+                    metadata=TraceMetadata(tool_inputs={
+                        "args": args, "kwargs": dict(kwargs_args)
+                    }),
+                    usage_info=UsageInfo(token_usage=TokenUsageBaseModel()),
+                )
+
+                # Store the UUID to ensure the END event uses the same ID
+                step_uuid = stats.UUID
+                self.step_manager.push_intermediate_step(stats)
+
+                with self._lock:
+                    self.last_call_ts = now
+
+                # Call the original _use(...)
+                if original_func is None:
+                    raise RuntimeError(
+                        "Original tool function is None - instrumentation may not have been set up correctly")
+                result = await original_func(base_tool_instance, *args, **kwargs)
+                now = time.time()
+                # Post-call usage stats - safely extract kwargs args if present
+                kwargs_args = (kwargs.get("args", {}) if isinstance(kwargs.get("args"), dict) else {})
+                usage_stat = IntermediateStepPayload(
+                    event_type=IntermediateStepType.TOOL_END,
+                    span_event_timestamp=now,
+                    framework=LLMFrameworkEnum.ADK,
+                    name=tool_name,
+                    data=StreamEventData(
+                        input={
+                            "args": args, "kwargs": dict(kwargs_args)
+                        },
+                        output=str(result),
+                    ),
+                    metadata=TraceMetadata(tool_outputs={"result": str(result)}),
+                    usage_info=UsageInfo(token_usage=TokenUsageBaseModel()),
+                    UUID=step_uuid,  # Use the same UUID as the START event
+                )
+
+                self.step_manager.push_intermediate_step(usage_stat)
+
+                return result
+
+            except Exception as _e:
+                logger.exception("BaseTool error occured")
+                raise
+
+        return wrapped_tool_use
+
+    def _llm_call_monkey_patch(self) -> Callable[..., Any]:
+        """
+        Returns a function that wraps calls to litellm.acompletion(...) with usage-logging.
+
+        Returns:
+            Callable[..., Any]: The wrapped function.
+        """
+        original_func = self._original_llm_call
+
+        async def wrapped_llm_call(*args, **kwargs) -> Any:
+            """
+            Replicates _llm_call_wrapper logic without wrapt: collects usage stats,
+            calls the original, and captures output stats.
+
+            Args:
+                *args: Positional arguments to the LLM call.
+                **kwargs: Keyword arguments to the LLM call.
+
+            Returns:
+                Any: The result of the LLM call.
+            """
+
+            now = time.time()
+            with self._lock:
+                seconds_between_calls = int(now - self.last_call_ts)
+            model_name = kwargs.get("model")
+            if not model_name and args:
+                first = args[0]
+                if isinstance(first, str):
+                    model_name = first
+            model_name = model_name or ""
+
+            model_input = ""
+            try:
+                for message in kwargs.get("messages", []):
+                    content = message.get("content", "")
+                    if isinstance(content, list):
+                        for part in content:
+                            if isinstance(part, dict):
+                                model_input += str(part.get("text", ""))  # text parts
+                            else:
+                                model_input += str(part)
+                    else:
+                        model_input += content or ""
+            except Exception as _e:
+                logger.exception("Error getting model input")
+
+            # Record the start event
+            input_stats = IntermediateStepPayload(
+                event_type=IntermediateStepType.LLM_START,
+                framework=LLMFrameworkEnum.ADK,
+                name=model_name,
+                data=StreamEventData(input=model_input),
+                metadata=TraceMetadata(chat_inputs=copy.deepcopy(kwargs.get("messages", []))),
+                usage_info=UsageInfo(
+                    token_usage=TokenUsageBaseModel(),
+                    num_llm_calls=1,
+                    seconds_between_calls=seconds_between_calls,
+                ),
+            )
+
+            # Store the UUID to ensure the END event uses the same ID
+            step_uuid = input_stats.UUID
+            self.step_manager.push_intermediate_step(input_stats)
+
+            # Call the original litellm.acompletion(...)
+            if original_func is None:
+                raise RuntimeError("Original LLM function is None - instrumentation may not have been set up correctly")
+            output = await original_func(*args, **kwargs)
+
+            model_output = ""
+            try:
+                for choice in output.choices:
+                    msg = choice.message
+                    model_output += msg.content or ""
+            except Exception as _e:
+                logger.exception("Error getting model output")
+
+            now = time.time()
+            # Record the end event
+            # Prepare safe metadata and usage
+            chat_resp: dict[str, Any] = {}
+            try:
+                if getattr(output, "choices", []):
+                    first_choice = output.choices[0]
+                    chat_resp = first_choice.model_dump() if hasattr(
+                        first_choice, "model_dump") else getattr(first_choice, "__dict__", {}) or {}
+            except Exception as _e:
+                logger.exception("Error preparing chat_responses")
+
+            usage_payload: dict[str, Any] = {}
+            try:
+                usage_obj = getattr(output, "usage", None) or (getattr(output, "model_extra", {}) or {}).get("usage")
+                if usage_obj:
+                    if hasattr(usage_obj, "model_dump"):
+                        usage_payload = usage_obj.model_dump()
+                    elif isinstance(usage_obj, dict):
+                        usage_payload = usage_obj
+            except Exception as _e:
+                logger.exception("Error preparing token usage")
+
+            output_stats = IntermediateStepPayload(
+                event_type=IntermediateStepType.LLM_END,
+                span_event_timestamp=now,
+                framework=LLMFrameworkEnum.ADK,
+                name=model_name,
+                data=StreamEventData(input=model_input, output=model_output),
+                metadata=TraceMetadata(chat_responses=chat_resp),
+                usage_info=UsageInfo(
+                    token_usage=TokenUsageBaseModel(**usage_payload),
+                    num_llm_calls=1,
+                    seconds_between_calls=seconds_between_calls,
+                ),
+                UUID=step_uuid,  # Use the same UUID as the START event
+            )
+
+            self.step_manager.push_intermediate_step(output_stats)
+
+            with self._lock:
+                self.last_call_ts = now
+
+            return output
+
+        return wrapped_llm_call

nat/plugins/adk/llm.py

@@ -0,0 +1,108 @@
+# 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 os
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.cli.register_workflow import register_llm_client
+from nat.llm.azure_openai_llm import AzureOpenAIModelConfig
+from nat.llm.litellm_llm import LiteLlmModelConfig
+from nat.llm.nim_llm import NIMModelConfig
+from nat.llm.openai_llm import OpenAIModelConfig
+
+logger = logging.getLogger(__name__)
+
+
+@register_llm_client(config_type=AzureOpenAIModelConfig, wrapper_type=LLMFrameworkEnum.ADK)
+async def azure_openai_adk(config: AzureOpenAIModelConfig, _builder: Builder):
+    """Create and yield a Google ADK `AzureOpenAI` client from a NAT `AzureOpenAIModelConfig`.
+
+    Args:
+        config (AzureOpenAIModelConfig): The configuration for the AzureOpenAI model.
+        _builder (Builder): The NAT builder instance.
+    """
+    from google.adk.models.lite_llm import LiteLlm
+
+    config_dict = config.model_dump(
+        exclude={"type", "max_retries", "thinking", "azure_endpoint", "azure_deployment", "model_name", "model"},
+        by_alias=True,
+        exclude_none=True,
+    )
+    if config.azure_endpoint:
+        config_dict["api_base"] = config.azure_endpoint
+
+    yield LiteLlm(f"azure/{config.azure_deployment}", **config_dict)
+
+
+@register_llm_client(config_type=LiteLlmModelConfig, wrapper_type=LLMFrameworkEnum.ADK)
+async def litellm_adk(litellm_config: LiteLlmModelConfig, _builder: Builder):
+    from google.adk.models.lite_llm import LiteLlm
+    yield LiteLlm(**litellm_config.model_dump(
+        exclude={"type", "max_retries", "thinking"},
+        by_alias=True,
+        exclude_none=True,
+    ))
+
+
+@register_llm_client(config_type=NIMModelConfig, wrapper_type=LLMFrameworkEnum.ADK)
+async def nim_adk(config: NIMModelConfig, _builder: Builder):
+    """Create and yield a Google ADK `NIM` client from a NAT `NIMModelConfig`.
+
+    Args:
+        config (NIMModelConfig): The configuration for the NIM model.
+        _builder (Builder): The NAT builder instance.
+    """
+    import litellm
+    from google.adk.models.lite_llm import LiteLlm
+
+    logger.warning("NIMs do not currently support tools with ADK. Tools will be ignored.")
+    litellm.add_function_to_prompt = True
+    litellm.drop_params = True
+
+    if (api_key := os.getenv("NVIDIA_API_KEY", None)) is not None:
+        os.environ["NVIDIA_NIM_API_KEY"] = api_key
+
+    config_dict = config.model_dump(
+        exclude={"type", "max_retries", "thinking", "model_name", "model", "base_url"},
+        by_alias=True,
+        exclude_none=True,
+    )
+    if config.base_url:
+        config_dict["api_base"] = config.base_url
+
+    yield LiteLlm(f"nvidia_nim/{config.model_name}", **config_dict)
+
+
+@register_llm_client(config_type=OpenAIModelConfig, wrapper_type=LLMFrameworkEnum.ADK)
+async def openai_adk(config: OpenAIModelConfig, _builder: Builder):
+    """Create and yield a Google ADK `OpenAI` client from a NAT `OpenAIModelConfig`.
+
+    Args:
+        config (OpenAIModelConfig): The configuration for the OpenAI model.
+        _builder (Builder): The NAT builder instance.
+    """
+    from google.adk.models.lite_llm import LiteLlm
+
+    config_dict = config.model_dump(
+        exclude={"type", "max_retries", "thinking", "model_name", "model", "base_url"},
+        by_alias=True,
+        exclude_none=True,
+    )
+    if config.base_url:
+        config_dict["api_base"] = config.base_url
+
+    yield LiteLlm(config.model_name, **config_dict)

nat/plugins/adk/register.py

@@ -0,0 +1,21 @@
+# 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.
+
+# pylint: disable=unused-import
+# flake8: noqa
+
+from . import adk_callback_handler
+from . import llm
+from . import tool_wrapper

nat/plugins/adk/tool_wrapper.py

@@ -0,0 +1,159 @@
+# 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.
+"""Tool Wrapper file"""
+import logging
+import types
+from collections.abc import AsyncIterator
+from collections.abc import Callable
+from dataclasses import is_dataclass
+from typing import Any
+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 resolve_type(t: Any) -> Any:
+    """Return the non-None member of a Union/PEP 604 union;
+    otherwise return the type unchanged.
+
+    Args:
+        t (Any): The type to resolve.
+
+    Returns:
+        Any: The resolved type.
+    """
+    origin = get_origin(t)
+    if origin is types.UnionType:
+        for arg in get_args(t):
+            if arg is not type(None):
+                return arg
+        return t
+    return t
+
+
+@register_tool_wrapper(wrapper_type=LLMFrameworkEnum.ADK)
+def google_adk_tool_wrapper(
+    name: str,
+    fn: Function,
+    _builder: Builder  # pylint: disable=W0613
+) -> Any:  # Changed from Callable[..., Any] to Any to allow FunctionTool return
+    """Wrap a NAT `Function` as a Google ADK `FunctionTool`.
+
+    Args:
+        name (str): The name of the tool.
+        fn (Function): The NAT `Function` to wrap.
+        _builder (Builder): The NAT `Builder` (not used).
+    Returns:
+        A Google ADK `FunctionTool` wrapping the NAT `Function`.
+    """
+    import inspect
+
+    async def callable_ainvoke(*args: Any, **kwargs: Any) -> Any:
+        """Async function to invoke the NAT function.
+
+        Args:
+            *args: Positional arguments to pass to the NAT function.
+            **kwargs: Keyword arguments to pass to the NAT function.
+        Returns:
+            Any: The result of invoking the NAT function.
+        """
+        return await fn.acall_invoke(*args, **kwargs)
+
+    async def callable_astream(*args: Any, **kwargs: Any) -> AsyncIterator[Any]:
+        """Async generator to stream results from the NAT function.
+
+        Args:
+            *args: Positional arguments to pass to the NAT function.
+            **kwargs: Keyword arguments to pass to the NAT function.
+        Yields:
+            Any: Streamed items from the NAT function.
+        """
+        async for item in fn.acall_stream(*args, **kwargs):
+            yield item
+
+    def nat_function(
+        func: Callable[..., Any] | None = None,
+        *,
+        name: str = name,
+        description: str | None = fn.description,
+        input_schema: Any = fn.input_schema,
+    ) -> Callable[..., Any]:
+        """
+        Decorator to wrap a function as a NAT function.
+
+        Args:
+            func (Callable): The function to wrap.
+            name (str): The name of the function.
+            description (str): The description of the function.
+            input_schema (BaseModel): The Pydantic model defining the input schema.
+
+        Returns:
+            Callable[..., Any]: The wrapped function.
+        """
+        if func is None:
+            raise ValueError("'func' must be provided.")
+
+        # If input_schema is a dataclass, convert it to a Pydantic model
+        if input_schema is not None and is_dataclass(input_schema):
+            input_schema = BaseModel.model_validate(input_schema)
+
+        def decorator(func_to_wrap: Callable[..., Any]) -> Callable[..., Any]:
+            """
+            Decorator to set metadata on the function.
+            """
+            # Set the function's metadata
+            if name is not None:
+                func_to_wrap.__name__ = name
+            if description is not None:
+                func_to_wrap.__doc__ = description
+
+            # Set signature only if input_schema is provided
+            params: list[inspect.Parameter] = []
+            if input_schema is not None:
+                annotations = getattr(input_schema, "__annotations__", {}) or {}
+                for param_name, param_annotation in annotations.items():
+                    params.append(
+                        inspect.Parameter(
+                            param_name,
+                            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                            annotation=resolve_type(param_annotation),
+                        ))
+            setattr(func_to_wrap, "__signature__", inspect.Signature(parameters=params))
+
+            return func_to_wrap
+
+        # If func is None, return the decorator itself to be applied later
+        if func is None:
+            return decorator
+        # Otherwise, apply the decorator to the provided function
+        return decorator(func)
+
+    from google.adk.tools.function_tool import FunctionTool
+
+    if fn.has_streaming_output and not fn.has_single_output:
+        logger.debug("Creating streaming FunctionTool for: %s", name)
+        callable_tool = nat_function(func=callable_astream)
+    else:
+        logger.debug("Creating non-streaming FunctionTool for: %s", name)
+        callable_tool = nat_function(func=callable_ainvoke)
+    return FunctionTool(callable_tool)

nvidia_nat_adk-1.1.0a20251020.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-adk
+Version: 1.1.0a20251020
+Summary: Subpackage for Google ADK 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[litellm]==v1.1.0a20251020
+Requires-Dist: google-adk~=1.14.1
+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://raw.githubusercontent.com/NVIDIA/NeMo-Agent-Toolkit/main/docs/source/_static/banner.png "NeMo Agent Toolkit banner")
+
+# NVIDIA NeMo Agent Toolkit — Google ADK Subpackage
+Subpackage providing Google ADK integration for the NVIDIA NeMo Agent Toolkit.