nvidia-nat-agno 1.2.0__py3-none-any.whl

nat/meta/pypi.md

@@ -0,0 +1,25 @@
+<!--
+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
+
+<!-- Note: "Agno" is the official product name despite Vale spelling checker warnings -->
+This is a subpackage for `Agno` 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/agno/llm.py

@@ -0,0 +1,87 @@
+# 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 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.data_models.retry_mixin import RetryMixin
+from nat.llm.nim_llm import NIMModelConfig
+from nat.llm.openai_llm import OpenAIModelConfig
+from nat.utils.exception_handlers.automatic_retries import patch_with_retry
+
+
+@register_llm_client(config_type=NIMModelConfig, wrapper_type=LLMFrameworkEnum.AGNO)
+async def nim_agno(llm_config: NIMModelConfig, builder: Builder):
+
+    from agno.models.nvidia import Nvidia
+
+    config_obj = {
+        **llm_config.model_dump(exclude={"type", "model_name"}, by_alias=True),
+        "id": f"{llm_config.model_name}",
+    }
+
+    # Because Agno uses a different environment variable for the API key, we need to set it here manually
+    if ("api_key" not in config_obj or config_obj["api_key"] is None):
+
+        if ("NVIDIA_API_KEY" in os.environ):
+            # Dont need to do anything. User has already set the correct key
+            pass
+        else:
+            nvidai_api_key = os.getenv("NVIDIA_API_KEY")
+
+            if (nvidai_api_key is not None):
+                # Transfer the key to the correct environment variable
+                os.environ["NVIDIA_API_KEY"] = nvidai_api_key
+
+    # Create Nvidia instance with conditional base_url
+    kwargs = {"id": config_obj.get("id")}
+    if "base_url" in config_obj and config_obj.get("base_url") is not None:
+        kwargs["base_url"] = config_obj.get("base_url")
+
+    client = Nvidia(**kwargs)  # type: ignore[arg-type]
+
+    if isinstance(client, 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)
+
+    yield client
+
+
+@register_llm_client(config_type=OpenAIModelConfig, wrapper_type=LLMFrameworkEnum.AGNO)
+async def openai_agno(llm_config: OpenAIModelConfig, builder: Builder):
+
+    from agno.models.openai import OpenAIChat
+
+    # Use model_dump to get the proper field values with correct types
+    kwargs = llm_config.model_dump(exclude={"type"}, by_alias=True)
+
+    # AGNO uses 'id' instead of 'model' for the model name
+    if "model" in kwargs:
+        kwargs["id"] = kwargs.pop("model")
+
+    client = OpenAIChat(**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)
+
+    yield client

nat/plugins/agno/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.
+
+# pylint: disable=unused-import
+# flake8: noqa
+# isort:skip_file
+
+from . import llm
+from . import tool_wrapper
+from .tools import register

nat/plugins/agno/tool_wrapper.py

@@ -0,0 +1,366 @@
+# 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 asyncio
+import json
+import logging
+import textwrap
+import traceback
+from typing import Any
+from typing import Awaitable
+from typing import Callable
+from typing import List
+
+from agno.tools import tool
+
+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__)
+
+# Add a module-level dictionary to track tool call counts for each tool
+_tool_call_counters = {}
+_MAX_EMPTY_CALLS = 1  # Maximum number of empty/metadata-only calls before signaling a problem
+# For better UX, stop after just 1 empty call for search tools
+
+# Dictionary to track which tools have already handled an initialization call
+_tool_initialization_done = {}
+
+
+async def process_result(result: Any, name: str) -> str:
+    """
+    Process the result from a function to ensure it's in the expected format.
+    This function guarantees that the output will be a properly formatted string,
+    suitable for consumption by language models like OpenAI's API.
+
+    Parameters
+    ----------
+    result : Any
+        The result to process
+    name : str
+        The name of the tool (for logging)
+
+    Returns
+    -------
+    str: The processed result as a properly formatted string
+    """
+    logger.debug(f"{name} processing result of type {type(result)}")
+
+    # Handle None or empty results
+    if result is None:
+        logger.warning(f"{name} returned None, converting to empty string")
+        return ""
+
+    # If the result is already a string, validate and return it
+    if isinstance(result, str):
+        logger.debug(f"{name} returning string result directly")
+        # Ensure result is not empty
+        if not result.strip():
+            return f"The {name} tool completed successfully but returned an empty result."
+        return result
+
+    # Handle Agno Agent.arun response objects
+    if hasattr(result, 'content'):
+        logger.debug(f"{name} returning result.content")
+        content = result.content
+        # Make sure content is a string
+        if not isinstance(content, str):
+            logger.debug(f"{name} result.content is not a string, converting")
+            content = str(content)
+        return content
+
+    # Handle OpenAI style responses
+    if hasattr(result, 'choices') and len(result.choices) > 0:
+        if hasattr(result.choices[0], 'message') and hasattr(result.choices[0].message, 'content'):
+            logger.debug(f"{name} returning result.choices[0].message.content")
+            return str(result.choices[0].message.content)
+        elif hasattr(result.choices[0], 'text'):
+            logger.debug(f"{name} returning result.choices[0].text")
+            return str(result.choices[0].text)
+
+    # Handle list of dictionaries by converting to a formatted string
+    if isinstance(result, list):
+        logger.debug(f"{name} converting list to string")
+        if len(result) == 0:
+            return f"The {name} tool returned an empty list."
+
+        if all(isinstance(item, dict) for item in result):
+            logger.debug(f"{name} converting list of dictionaries to string")
+            formatted_result = ""
+            for i, item in enumerate(result, 1):
+                formatted_result += f"Result {i}:\n"
+                for k, v in item.items():
+                    formatted_result += f"  {k}: {v}\n"
+                formatted_result += "\n"
+            return formatted_result
+        else:
+            # For other lists, convert to a simple list format
+            formatted_result = "Results:\n\n"
+            for i, item in enumerate(result, 1):
+                formatted_result += f"{i}. {str(item)}\n"
+            return formatted_result
+
+    # Handle dictionaries
+    if isinstance(result, dict):
+        logger.debug(f"{name} converting dictionary to string")
+        try:
+            # Try to format as JSON for readability
+            return json.dumps(result, indent=2)
+        except (TypeError, OverflowError):
+            # Fallback to manual formatting if JSON fails
+            formatted_result = "Result:\n\n"
+            for k, v in result.items():
+                formatted_result += f"{k}: {v}\n"
+            return formatted_result
+
+    # For all other types, convert to string
+    logger.debug(f"{name} converting {type(result)} to string")
+    return str(result)
+
+
+def execute_agno_tool(name: str,
+                      coroutine_fn: Callable[..., Awaitable[Any]],
+                      required_fields: List[str],
+                      loop: asyncio.AbstractEventLoop,
+                      **kwargs: Any) -> Any:
+    """
+    Execute an Agno tool with the given parameters.
+
+    Parameters
+    ----------
+    name : str
+        The name of the tool
+    coroutine_fn : Callable
+        The async function to invoke
+    required_fields : List[str]
+        List of required fields for validation
+    loop : asyncio.AbstractEventLoop
+        The event loop to use for async execution
+    **kwargs : Any
+        The arguments to pass to the function
+
+    Returns
+    -------
+    The result of the function execution as a string
+    """
+    global _tool_call_counters, _tool_initialization_done
+
+    try:
+        logger.debug(f"Running {name} with kwargs: {kwargs}")
+
+        # Initialize counter for this tool if it doesn't exist
+        if name not in _tool_call_counters:
+            _tool_call_counters[name] = 0
+
+        # Track if this tool has already been initialized
+        if name not in _tool_initialization_done:
+            _tool_initialization_done[name] = False
+
+        # Filter out any known reserved keywords or metadata fields that might cause issues
+        # These are typically added by frameworks and not meant for the function itself
+        reserved_keywords = {'type', '_type', 'model_config', 'model_fields', 'model_dump', 'model_dump_json'}
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k not in reserved_keywords}
+
+        # Check if we're only receiving metadata fields (potential infinite loop indicator)
+        only_metadata = len(filtered_kwargs) == 0 and len(kwargs) > 0
+
+        # Check if this is a search api tool with empty query
+        is_search_api = name.lower().endswith("_api_tool")
+        has_empty_query = "query" in filtered_kwargs and (not filtered_kwargs["query"]
+                                                          or filtered_kwargs["query"].strip() == "")
+
+        # Log if we filtered anything
+        filtered_keys = set(kwargs.keys()) - set(filtered_kwargs.keys())
+        if filtered_keys:
+            logger.debug(f"Filtered reserved keywords from kwargs: {filtered_keys}")
+
+        # IMPORTANT: Special handling for SerpApi and other search API calls
+        if is_search_api and (only_metadata or has_empty_query):
+            # If this is the first time this tool is called with empty query, allow it for initialization
+            if not _tool_initialization_done[name]:
+                logger.info(f"First-time initialization call for {name}")
+                _tool_initialization_done[name] = True
+            else:
+                # If we've already initialized this tool, prevent repeated empty calls
+                logger.error(f"Tool {name} called with empty query after initialization. Blocking repeated calls.")
+                return f"ERROR: Tool {name} requires a valid query. Provide a specific search term to continue."
+
+        # IMPORTANT: Safeguard for infinite loops
+        # If we're only getting metadata fields and no actual parameters repeatedly
+        if only_metadata:
+            _tool_call_counters[name] += 1
+            logger.warning(
+                f"Tool {name} called with only metadata fields (call {_tool_call_counters[name]}/{_MAX_EMPTY_CALLS})")
+
+            # Break potential infinite loops after too many metadata-only calls
+            if _tool_call_counters[name] >= _MAX_EMPTY_CALLS:
+                logger.error(
+                    f"Detected potential infinite loop for tool {name} - received {_tool_call_counters[name]} calls")
+                _tool_call_counters[name] = 0  # Reset counter
+                return f"ERROR: Tool {name} appears to be in a loop. Provide parameters when calling this tool."
+        else:
+            # Reset counter when we get actual parameters
+            _tool_call_counters[name] = 0
+
+        # Fix for the 'kwargs' wrapper issue - unwrap if needed
+        if len(filtered_kwargs) == 1 and 'kwargs' in filtered_kwargs and isinstance(filtered_kwargs['kwargs'], dict):
+            logger.debug("Detected wrapped kwargs, unwrapping")
+            # If input is {'kwargs': {'actual': 'params'}}, we need to unwrap it
+            unwrapped_kwargs = filtered_kwargs['kwargs']
+
+            # Also filter the unwrapped kwargs
+            unwrapped_kwargs = {k: v for k, v in unwrapped_kwargs.items() if k not in reserved_keywords}
+
+            # Check if we're missing required fields and try to recover
+            for field in required_fields:
+                if field not in unwrapped_kwargs:
+                    logger.warning(f"Missing required field '{field}' in unwrapped kwargs: {unwrapped_kwargs}")
+                    # Try to build a query from all the provided values if query is required
+                    if field == 'query' and len(unwrapped_kwargs) > 0:
+                        # Simple fallback for search tools - cobble together a query string
+                        query_parts = []
+                        for k, v in unwrapped_kwargs.items():
+                            query_parts.append(f"{k}: {v}")
+                        unwrapped_kwargs['query'] = " ".join(query_parts)
+                        logger.info(f"Built fallback query: {unwrapped_kwargs['query']}")
+
+            filtered_kwargs = unwrapped_kwargs
+
+        # Special handling for initialization calls - these are often empty or partial
+        is_initialization = len(filtered_kwargs) == 0
+
+        # Further validation to ensure all required fields are present
+        # If this looks like an initialization call, we'll be more lenient
+        missing_fields = []
+        for field in required_fields:
+            if field not in filtered_kwargs:
+                missing_fields.append(field)
+                logger.warning(f"Missing field '{field}' in kwargs: {filtered_kwargs}")
+
+        # Special handling for search tools - query can be optional during initialization
+        if not is_initialization and missing_fields and "query" in missing_fields and name.lower().endswith(
+                "_api_tool"):
+            logger.info(f"Tool {name} was called without a 'query' parameter, treating as initialization")
+            is_initialization = True
+
+        # Only enforce required fields for non-initialization calls
+        if not is_initialization and missing_fields:
+            if "query" in missing_fields:
+                # Add a specific message for missing query
+                raise ValueError(f"Missing required parameter 'query'. The tool {name} requires a search query.")
+            else:
+                missing_fields_str = ", ".join([f"'{f}'" for f in missing_fields])
+                raise ValueError(f"Missing required parameters: {missing_fields_str} for {name}.")
+
+        logger.debug(f"Invoking function with parameters: {filtered_kwargs}")
+
+        # Try different calling styles to handle both positional and keyword arguments
+        try:
+            # First try calling with kwargs directly - this works for functions that use **kwargs
+            future = asyncio.run_coroutine_threadsafe(coroutine_fn(**filtered_kwargs), loop)
+            result = future.result(timeout=120)  # 2-minute timeout
+        except TypeError as e:
+            if "missing 1 required positional argument: 'input_obj'" in str(e):
+                # If we get a specific error about missing positional arg, try passing as positional
+                logger.debug(f"Retrying with positional argument style for {name}")
+                future = asyncio.run_coroutine_threadsafe(coroutine_fn(filtered_kwargs), loop)
+                result = future.result(timeout=120)  # 2-minute timeout
+            else:
+                # For other TypeError errors, reraise
+                raise
+
+        # Always process the result to ensure proper formatting, regardless of type
+        process_future = asyncio.run_coroutine_threadsafe(process_result(result, name), loop)
+        return process_future.result(timeout=30)  # 30-second timeout for processing
+
+    except Exception as e:
+        logger.exception(f"Error executing Agno tool {name}: {e}")
+        error_traceback = traceback.format_exc()
+        logger.error(f"Exception traceback: {error_traceback}")
+        raise
+
+
+@register_tool_wrapper(wrapper_type=LLMFrameworkEnum.AGNO)
+def agno_tool_wrapper(name: str, fn: Function, builder: Builder):
+    """
+    Wraps a NAT Function to be usable as an Agno tool.
+
+    This wrapper handles the conversion of async NAT functions to
+    the format expected by Agno tools. It properly handles input schema,
+    descriptions, and async invocation.
+
+    Parameters
+    ----------
+    name : str
+        The name of the tool
+    fn : Function
+        The NAT Function to wrap
+    builder : Builder
+        The builder instance
+
+    Returns
+    -------
+    A callable that can be used as an Agno tool
+    """
+    # Ensure input schema is present
+    assert fn.input_schema is not None, "Tool must have input schema"
+
+    # Get the event loop for running async functions
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # If there's no running event loop, create a new one
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    # Get the async function to invoke
+    coroutine_fn = fn.acall_invoke
+
+    # Extract metadata for the tool
+    description = fn.description or ""
+    if description:
+        description = textwrap.dedent(description).strip()
+
+    # Input schema handling from LangChain-style
+    required_fields = []
+    if fn.input_schema is not None:
+        try:
+            schema_json = fn.input_schema.model_json_schema()
+            required_fields = schema_json.get("required", [])
+            # Add schema description to the tool description if available
+            schema_desc = schema_json.get("description")
+            if schema_desc and schema_desc not in description:
+                description = f"{description}\n\nArguments: {schema_desc}"
+        except Exception as e:
+            logger.warning(f"Error extracting JSON schema from input_schema: {e}")
+
+    # Create a function specific to this tool with proper closure variables
+    def tool_sync_wrapper(**kwargs: Any) -> Any:
+        """Synchronous implementation of the tool function."""
+        return execute_agno_tool(name, coroutine_fn, required_fields, loop, **kwargs)
+
+    # Prepare the documentation for the tool
+    if description:
+        tool_sync_wrapper.__doc__ = description
+
+    # Set the function name
+    tool_sync_wrapper.__name__ = name
+
+    # Apply the tool decorator and return it
+    decorated_tool = tool(name=name, description=description)(tool_sync_wrapper)
+
+    return decorated_tool

nat/plugins/agno/tools/register.py

@@ -0,0 +1,20 @@
+# 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
+# isort:skip_file
+
+from . import serp_api_tool

nat/plugins/agno/tools/serp_api_tool.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.
+
+import logging
+import os
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.function import FunctionBaseConfig
+
+logger = logging.getLogger(__name__)
+
+
+class SerpApiToolConfig(FunctionBaseConfig, name="serp_api_tool"):
+    """
+    Tool that retrieves search results from the web using SerpAPI.
+    Requires a SERP_API_KEY.
+    """
+    api_key: str | None = Field(default=None, description="The API key for the SerpAPI service.")
+    max_results: int = Field(default=5, description="The maximum number of results to return.")
+
+
+@register_function(config_type=SerpApiToolConfig, framework_wrappers=[LLMFrameworkEnum.AGNO])
+async def serp_api_tool(tool_config: SerpApiToolConfig, builder: Builder):
+    """Create a SerpAPI search tool for use with Agno.
+
+    This creates a search function that uses SerpAPI to search the web.
+
+    Args:
+        tool_config (SerpApiToolConfig): Configuration for the SerpAPI tool.
+        builder (Builder): The NAT builder instance.
+
+    Returns:
+        FunctionInfo: A FunctionInfo object wrapping the SerpAPI search functionality.
+    """
+    import json
+
+    from agno.tools.serpapi import SerpApiTools
+
+    if (not tool_config.api_key):
+        tool_config.api_key = os.getenv("SERP_API_KEY")
+
+    if not tool_config.api_key:
+        raise ValueError(
+            "API token must be provided in the configuration or in the environment variable `SERP_API_KEY`")
+
+    # Create the SerpAPI tools instance
+    search_tool = SerpApiTools(api_key=tool_config.api_key)
+
+    # Simple search function with a single string parameter
+    async def _serp_api_search(query: str) -> str:
+        """
+        Search the web using SerpAPI.
+
+        Args:
+            query (str): The search query to perform. If empty, returns initialization message.
+
+        Returns:
+            str: Formatted search results or initialization message.
+        """
+
+        if not query or query.strip() == "":
+            exception_msg = "Search query cannot be empty. Please provide a specific search term to continue."
+            logger.warning(exception_msg)
+            return exception_msg
+
+        logger.info("Searching SerpAPI with query: '%s', max_results: %s", query, tool_config.max_results)
+
+        try:
+            # Perform the search
+            raw_all_results: str = search_tool.search_google(query=query, num_results=tool_config.max_results)
+            all_results: dict = json.loads(raw_all_results)
+            search_results = all_results.get('search_results', [])
+
+            logger.info("SerpAPI returned %s results", len(search_results))
+
+            # Format the results as a string
+            formatted_results = []
+            for result in search_results:
+                title = result.get('title', 'No Title')
+                link = result.get('link', 'No Link')
+                snippet = result.get('snippet', 'No Snippet')
+
+                formatted_result = f'<Document href="{link}"/>\n'
+                formatted_result += f'# {title}\n\n'
+                formatted_result += f'{snippet}\n'
+                formatted_result += '</Document>'
+                formatted_results.append(formatted_result)
+
+            return "\n\n---\n\n".join(formatted_results)
+        except Exception as e:
+            logger.exception("Error searching with SerpAPI: %s", e)
+            return f"Error performing search: {str(e)}"
+
+    fn_info = FunctionInfo.from_fn(
+        _serp_api_search,
+        description="""This tool searches the web using SerpAPI and returns relevant results for the given query.""")
+
+    yield fn_info

nvidia_nat_agno-1.2.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-agno
+Version: 1.2.0
+Summary: Subpackage for Agno integration in NeMo Agent toolkit
+Keywords: ai,rag,agents
+Classifier: Programming Language :: Python
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: nvidia-nat==v1.2.0
+Requires-Dist: agno~=1.2.3
+Requires-Dist: openai~=1.66
+Requires-Dist: google-search-results~=2.4.2
+
+<!--
+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
+
+<!-- Note: "Agno" is the official product name despite Vale spelling checker warnings -->
+This is a subpackage for `Agno` 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_agno-1.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+nat/meta/pypi.md,sha256=tZD7hiOSYWgiAdddD1eIJ8T5ipZwEIjnd8ilgmasdmw,1198
+nat/plugins/agno/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nat/plugins/agno/llm.py,sha256=hvPu0-gkRasnWZY5kwHOiA6rZ1ZIGlnaH3nPPfqrFJ8,3434
+nat/plugins/agno/register.py,sha256=6vC1TjMxo3igqTnEtVFgLEf_jgLYkBfBZxjwqxGng6w,820
+nat/plugins/agno/tool_wrapper.py,sha256=uClYG-LvRj1OBTMwzMuE40cibLhqVRXSCiqniVQND2Y,15914
+nat/plugins/agno/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nat/plugins/agno/tools/register.py,sha256=OCmzR03CHmQHm34ZEascM1dRVh-ALMs2mafDcqLDz6s,775
+nat/plugins/agno/tools/serp_api_tool.py,sha256=AJQH6-1iEUUrk_nzfZ3zZqutEKhJ_LMOUJi_iol65Sc,4442
+nvidia_nat_agno-1.2.0.dist-info/METADATA,sha256=ZCu94sJKFSIJITS1Gi1kF7E35qvaM6RZaZakb7dirMM,1591
+nvidia_nat_agno-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_agno-1.2.0.dist-info/entry_points.txt,sha256=qRhuHKj2WmdJkLpbVXpYkdtc2cZdG4LPlBsABG2ImVI,103
+nvidia_nat_agno-1.2.0.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_agno-1.2.0.dist-info/RECORD,,

nvidia_nat_agno-1.2.0.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_agno-1.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[nat.components]
+nat_agno = nat.plugins.agno.register
+nat_agno_tools = nat.plugins.agno.tools.register

nvidia_nat_agno-1.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nat