nvidia-nat-crewai 1.1.0a20251020__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 CrewAI 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/crewai/crewai_callback_handler.py

@@ -0,0 +1,206 @@
+# 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
+
+import litellm
+from crewai.tools import tool_usage
+
+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 CrewAIProfilerHandler(BaseProfilerCallback):
+    """
+    A callback manager/handler for CrewAI that intercepts calls to:
+      - ToolUsage._use
+      - LLM Calls
+
+    to collect usage statistics (tokens, inputs, outputs, time intervals, etc.)
+    and store them in NAT'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 CrewAI methods (for uninstrumenting if needed)
+        self._original_tool_use = None
+        self._original_llm_call = None
+
+    def instrument(self) -> None:
+        """
+        Monkey-patch the relevant CrewAI methods with usage-stat collection logic.
+        Assumes the 'crewai' library is installed.
+        """
+
+        # Save the originals
+        self._original_tool_use = getattr(tool_usage.ToolUsage, "_use", None)
+        self._original_llm_call = getattr(litellm, "completion", None)
+
+        # Patch if available
+        if self._original_tool_use:
+            tool_usage.ToolUsage._use = self._tool_use_monkey_patch()
+
+        if self._original_llm_call:
+            litellm.completion = self._llm_call_monkey_patch()
+
+        logger.debug("CrewAIProfilerHandler instrumentation applied successfully.")
+
+    def _tool_use_monkey_patch(self) -> Callable[..., Any]:
+        """
+        Returns a function that wraps calls to ToolUsage._use(...) with usage-logging.
+        """
+        original_func = self._original_tool_use
+
+        def wrapped_tool_use(tool_usage_instance, *args, **kwargs) -> Any:
+            """
+            Replicates _tool_use_wrapper logic without wrapt: collects usage stats,
+            calls the original, and captures output stats.
+            """
+            now = time.time()
+            tool_name = ""
+
+            try:
+                tool_info = kwargs.get("tool", "")
+
+                if tool_info:
+                    tool_name = tool_info.name
+            except Exception as e:
+                logger.exception("Error getting tool name: %s", e)
+
+            try:
+                # Pre-call usage event
+                stats = IntermediateStepPayload(event_type=IntermediateStepType.TOOL_START,
+                                                framework=LLMFrameworkEnum.CREWAI,
+                                                name=tool_name,
+                                                data=StreamEventData(),
+                                                metadata=TraceMetadata(tool_inputs={
+                                                    "args": args, "kwargs": dict(kwargs)
+                                                }),
+                                                usage_info=UsageInfo(token_usage=TokenUsageBaseModel()))
+
+                self.step_manager.push_intermediate_step(stats)
+
+                self.last_call_ts = now
+
+                # Call the original _use(...)
+                result = original_func(tool_usage_instance, *args, **kwargs)
+                now = time.time()
+                # Post-call usage stats
+                usage_stat = IntermediateStepPayload(
+                    event_type=IntermediateStepType.TOOL_END,
+                    span_event_timestamp=now,
+                    framework=LLMFrameworkEnum.CREWAI,
+                    name=tool_name,
+                    data=StreamEventData(input={
+                        "args": args, "kwargs": dict(kwargs)
+                    }, output=str(result)),
+                    metadata=TraceMetadata(tool_outputs={"result": str(result)}),
+                    usage_info=UsageInfo(token_usage=TokenUsageBaseModel()),
+                )
+
+                self.step_manager.push_intermediate_step(usage_stat)
+
+                return result
+
+            except Exception as e:
+                logger.error("ToolUsage._use error: %s", e)
+                raise
+
+        return wrapped_tool_use
+
+    def _llm_call_monkey_patch(self) -> Callable[..., Any]:
+        """
+        Returns a function that wraps calls to litellm.completion(...) with usage-logging.
+        """
+        original_func = self._original_llm_call
+
+        def wrapped_llm_call(*args, **kwargs) -> Any:
+            """
+            Replicates _llm_call_wrapper logic without wrapt: collects usage stats,
+            calls the original, and captures output stats.
+            """
+
+            now = time.time()
+            seconds_between_calls = int(now - self.last_call_ts)
+            model_name = kwargs.get('model', "")
+
+            model_input = ""
+            try:
+                for message in kwargs.get('messages', []):
+                    model_input += message.get('content', "")
+            except Exception as e:
+                logger.exception("Error getting model input: %s", e)
+
+            # Record the start event
+            input_stats = IntermediateStepPayload(
+                event_type=IntermediateStepType.LLM_START,
+                framework=LLMFrameworkEnum.CREWAI,
+                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))
+
+            self.step_manager.push_intermediate_step(input_stats)
+
+            # Call the original litellm.completion(...)
+            output = original_func(*args, **kwargs)
+
+            model_output = ""
+            try:
+                for choice in output.choices:
+                    msg = choice.model_extra["message"]
+                    model_output += msg.get('content', "")
+            except Exception as e:
+                logger.exception("Error getting model output: %s", e)
+
+            now = time.time()
+            # Record the end event
+            output_stats = IntermediateStepPayload(
+                event_type=IntermediateStepType.LLM_END,
+                span_event_timestamp=now,
+                framework=LLMFrameworkEnum.CREWAI,
+                name=model_name,
+                data=StreamEventData(input=model_input, output=model_output),
+                metadata=TraceMetadata(chat_responses=output.choices[0].model_dump()),
+                usage_info=UsageInfo(token_usage=TokenUsageBaseModel(**output.model_extra['usage'].model_dump()),
+                                     num_llm_calls=1,
+                                     seconds_between_calls=seconds_between_calls))
+
+            self.step_manager.push_intermediate_step(output_stats)
+
+            # (Note: the original code did NOT update self.last_call_ts here)
+            return output
+
+        return wrapped_llm_call

nat/plugins/crewai/llm.py

@@ -0,0 +1,148 @@
+# 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 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.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.litellm_llm import LiteLlmModelConfig
+from nat.llm.nim_llm import NIMModelConfig
+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.type_utils import override
+
+ModelType = TypeVar("ModelType")
+
+
+def _patch_llm_based_on_config(client: ModelType, llm_config: LLMBaseConfig) -> ModelType:
+
+    class CrewAIThinkingInjector(BaseThinkingInjector):
+
+        @override
+        def inject(self, messages: list[dict[str, str]], *args, **kwargs) -> FunctionArgumentWrapper:
+            # Attempt to inject the system prompt into the first system message
+            for i, message in enumerate(messages):
+                if message["role"] == "system":
+                    if self.system_prompt not in message["content"]:
+                        messages = list(messages)
+                        messages[i] = {"role": "system", "content": f"{message['content']}\n{self.system_prompt}"}
+                    break
+            else:
+                messages = list(messages)
+                messages.insert(0, {"role": "system", "content": self.system_prompt})
+            return FunctionArgumentWrapper(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, CrewAIThinkingInjector(
+                system_prompt=llm_config.thinking_system_prompt,
+                function_names=["call"],
+            ))
+
+    return client
+
+
+@register_llm_client(config_type=AzureOpenAIModelConfig, wrapper_type=LLMFrameworkEnum.CREWAI)
+async def azure_openai_crewai(llm_config: AzureOpenAIModelConfig, _builder: Builder):
+
+    from crewai import LLM
+
+    # https://docs.crewai.com/en/concepts/llms#azure
+
+    api_key = llm_config.api_key or os.environ.get("AZURE_OPENAI_API_KEY") or os.environ.get("AZURE_API_KEY")
+    if api_key is None:
+        raise ValueError("Azure API key is not set")
+    os.environ["AZURE_API_KEY"] = api_key
+    api_base = (llm_config.azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT")
+                or os.environ.get("AZURE_API_BASE"))
+    if api_base is None:
+        raise ValueError("Azure endpoint is not set")
+    os.environ["AZURE_API_BASE"] = api_base
+
+    os.environ["AZURE_API_VERSION"] = llm_config.api_version
+    model = llm_config.azure_deployment or os.environ.get("AZURE_MODEL_DEPLOYMENT")
+    if model is None:
+        raise ValueError("Azure model deployment is not set")
+
+    client = LLM(
+        **llm_config.model_dump(
+            exclude={
+                "type",
+                "api_key",
+                "azure_endpoint",
+                "azure_deployment",
+                "thinking",
+            },
+            by_alias=True,
+            exclude_none=True,
+        ),
+        model=model,
+    )
+
+    yield _patch_llm_based_on_config(client, llm_config)
+
+
+@register_llm_client(config_type=NIMModelConfig, wrapper_type=LLMFrameworkEnum.CREWAI)
+async def nim_crewai(llm_config: NIMModelConfig, _builder: Builder):
+
+    from crewai import LLM
+
+    # Because CrewAI uses a different environment variable for the API key, we need to set it here manually
+    if llm_config.api_key is None and "NVIDIA_NIM_API_KEY" not in os.environ:
+        nvidia_api_key = os.getenv("NVIDIA_API_KEY")
+        if nvidia_api_key is not None:
+            os.environ["NVIDIA_NIM_API_KEY"] = nvidia_api_key
+
+    client = LLM(
+        **llm_config.model_dump(exclude={"type", "model_name", "thinking"}, by_alias=True, exclude_none=True),
+        model=f"nvidia_nim/{llm_config.model_name}",
+    )
+
+    yield _patch_llm_based_on_config(client, llm_config)
+
+
+@register_llm_client(config_type=OpenAIModelConfig, wrapper_type=LLMFrameworkEnum.CREWAI)
+async def openai_crewai(llm_config: OpenAIModelConfig, _builder: Builder):
+
+    from crewai import LLM
+
+    client = LLM(**llm_config.model_dump(exclude={"type", "thinking"}, by_alias=True, exclude_none=True))
+
+    yield _patch_llm_based_on_config(client, llm_config)
+
+
+@register_llm_client(config_type=LiteLlmModelConfig, wrapper_type=LLMFrameworkEnum.CREWAI)
+async def litellm_crewai(llm_config: LiteLlmModelConfig, _builder: Builder):
+
+    from crewai import LLM
+
+    client = LLM(**llm_config.model_dump(exclude={"type", "thinking"}, by_alias=True, exclude_none=True))
+
+    yield _patch_llm_based_on_config(client, llm_config)

nat/plugins/crewai/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/crewai/tool_wrapper.py

@@ -0,0 +1,40 @@
+# 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
+
+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
+
+
+@register_tool_wrapper(wrapper_type=LLMFrameworkEnum.CREWAI)
+def crewai_tool_wrapper(name: str, fn: Function, builder: Builder):
+
+    from crewai.tools.base_tool import Tool
+
+    # Capture the loop at the time this is called
+    loop = asyncio.get_event_loop()
+
+    # Capture the coroutine at the time this is called
+    runnable = fn.acall_invoke
+
+    # Because CrewAI tools are not async, we need to wrap the coroutine in a normal function
+    def wrapper(*args, **kwargs):
+
+        return asyncio.run_coroutine_threadsafe(runnable(*args, **kwargs), loop).result()
+
+    return Tool(name=name, description=fn.description or "", args_schema=fn.input_schema, func=wrapper)

nvidia_nat_crewai-1.1.0a20251020.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-crewai
+Version: 1.1.0a20251020
+Summary: Subpackage for CrewAI 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: crewai~=0.193.2
+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 CrewAI 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_crewai-1.1.0a20251020.dist-info/RECORD

@@ -0,0 +1,13 @@
+nat/meta/pypi.md,sha256=T68FnThRzDGFf1LR8u-okM-r11-skSnKqSyI6HOktQY,1107
+nat/plugins/crewai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nat/plugins/crewai/crewai_callback_handler.py,sha256=m5u0RqUd94F0iIuUvknhVHn1SxYltg3lxAhN_3AogPQ,8334
+nat/plugins/crewai/llm.py,sha256=sfQsdSK6WGWHscald4tG4dyXEcn6zqdhkFjE-1zAtJE,5984
+nat/plugins/crewai/register.py,sha256=_R3bhGmz___696_NwyIcpw3koMBiWqIFoWEFJ0VAgXs,831
+nat/plugins/crewai/tool_wrapper.py,sha256=BNKEPQQCLKtXNzGDAKBLCdmGJXe9lBOVI1hObha8hoI,1569
+nvidia_nat_crewai-1.1.0a20251020.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat_crewai-1.1.0a20251020.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat_crewai-1.1.0a20251020.dist-info/METADATA,sha256=dQCSEp77WYWT7tjyziMppNpyvU59LnjLDFojc4zAaD4,1922
+nvidia_nat_crewai-1.1.0a20251020.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_crewai-1.1.0a20251020.dist-info/entry_points.txt,sha256=YF5PUdQGr_OUDXB4TykElHJTsKT8yKkuE0bMX5n_RXs,58
+nvidia_nat_crewai-1.1.0a20251020.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_crewai-1.1.0a20251020.dist-info/RECORD,,

nvidia_nat_crewai-1.1.0a20251020.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_crewai-1.1.0a20251020.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[nat.components]
+nat_crewai = nat.plugins.crewai.register