nvidia-nat 1.3.0a20250928__py3-none-any.whl → 1.3.0a20250930__py3-none-any.whl

nat/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -25,18 +25,21 @@ from collections.abc import Callable
 from contextlib import asynccontextmanager
 from pathlib import Path
 
+import httpx
+from authlib.common.errors import AuthlibBaseError as OAuthError
 from fastapi import Body
 from fastapi import FastAPI
+from fastapi import HTTPException
 from fastapi import Request
 from fastapi import Response
 from fastapi import UploadFile
-from fastapi.exceptions import HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from pydantic import Field
 from starlette.websockets import WebSocket
 
+from nat.builder.function import Function
 from nat.builder.workflow_builder import WorkflowBuilder
 from nat.data_models.api_server import ChatRequest
 from nat.data_models.api_server import ChatResponse
@@ -241,6 +244,7 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
         await self.add_evaluate_route(app, SessionManager(await builder.build()))
         await self.add_static_files_route(app, builder)
         await self.add_authorization_route(app)
+        await self.add_mcp_client_tool_list_route(app, builder)
 
         for ep in self.front_end_config.endpoints:
 
@@ -1071,8 +1075,13 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                                                code_verifier=verifier,
                                                state=state)
                 flow_state.future.set_result(res)
+            except OAuthError as e:
+                flow_state.future.set_exception(
+                    RuntimeError(f"Authorization server rejected request: {e.error} ({e.description})"))
+            except httpx.HTTPError as e:
+                flow_state.future.set_exception(RuntimeError(f"Network error during token fetch: {e}"))
             except Exception as e:
-                flow_state.future.set_exception(e)
+                flow_state.future.set_exception(RuntimeError(f"Authentication failed: {e}"))
 
             return HTMLResponse(content=AUTH_REDIRECT_SUCCESS_HTML,
                                 status_code=200,
@@ -1088,6 +1097,183 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
                 methods=["GET"],
                 description="Handles the authorization code and state returned from the Authorization Code Grant Flow.")
 
+    async def add_mcp_client_tool_list_route(self, app: FastAPI, builder: WorkflowBuilder):
+        """Add the MCP client tool list endpoint to the FastAPI app."""
+        from typing import Any
+
+        from pydantic import BaseModel
+
+        class MCPToolInfo(BaseModel):
+            name: str
+            description: str
+            server: str
+            available: bool
+
+        class MCPClientToolListResponse(BaseModel):
+            mcp_clients: list[dict[str, Any]]
+
+        async def get_mcp_client_tool_list() -> MCPClientToolListResponse:
+            """
+            Get the list of MCP tools from all MCP clients in the workflow configuration.
+            Checks session health and compares with workflow function group configuration.
+            """
+            mcp_clients_info = []
+
+            try:
+                # Get all function groups from the builder
+                function_groups = builder._function_groups
+
+                # Find MCP client function groups
+                for group_name, configured_group in function_groups.items():
+                    if configured_group.config.type != "mcp_client":
+                        continue
+
+                    from nat.plugins.mcp.client_impl import MCPClientConfig
+
+                    config = configured_group.config
+                    assert isinstance(config, MCPClientConfig)
+
+                    # Reuse the existing MCP client session stored on the function group instance
+                    group_instance = configured_group.instance
+
+                    client = group_instance.mcp_client
+                    if client is None:
+                        raise RuntimeError(f"MCP client not found for group {group_name}")
+
+                    try:
+                        session_healthy = False
+                        server_tools: dict[str, Any] = {}
+
+                        try:
+                            server_tools = await client.get_tools()
+                            session_healthy = True
+                        except Exception as e:
+                            logger.exception(f"Failed to connect to MCP server {client.server_name}: {e}")
+                            session_healthy = False
+
+                        # Get workflow function group configuration (configured client-side tools)
+                        configured_short_names: set[str] = set()
+                        configured_full_to_fn: dict[str, Function] = {}
+                        try:
+                            # Pass a no-op filter function to bypass any default filtering that might check
+                            # health status, preventing potential infinite recursion during health status checks.
+                            async def pass_through_filter(fn):
+                                return fn
+
+                            accessible_functions = await group_instance.get_accessible_functions(
+                                filter_fn=pass_through_filter)
+                            configured_full_to_fn = accessible_functions
+                            configured_short_names = {name.split('.', 1)[1] for name in accessible_functions.keys()}
+                        except Exception as e:
+                            logger.exception(f"Failed to get accessible functions for group {group_name}: {e}")
+
+                        # Build alias->original mapping and override configs from overrides
+                        alias_to_original: dict[str, str] = {}
+                        override_configs: dict[str, Any] = {}
+                        try:
+                            if config.tool_overrides is not None:
+                                for orig_name, override in config.tool_overrides.items():
+                                    if override.alias is not None:
+                                        alias_to_original[override.alias] = orig_name
+                                        override_configs[override.alias] = override
+                                    else:
+                                        override_configs[orig_name] = override
+                        except Exception:
+                            pass
+
+                        # Create tool info list (always return configured tools; mark availability)
+                        tools_info: list[dict[str, Any]] = []
+                        available_count = 0
+                        for wf_fn, fn_short in zip(configured_full_to_fn.values(), configured_short_names):
+                            orig_name = alias_to_original.get(fn_short, fn_short)
+                            available = session_healthy and (orig_name in server_tools)
+                            if available:
+                                available_count += 1
+
+                            # Prefer tool override description, then workflow function description,
+                            # then server description
+                            description = ""
+                            if fn_short in override_configs and override_configs[fn_short].description:
+                                description = override_configs[fn_short].description
+                            elif wf_fn.description:
+                                description = wf_fn.description
+                            elif available and orig_name in server_tools:
+                                description = server_tools[orig_name].description or ""
+
+                            tools_info.append(
+                                MCPToolInfo(name=fn_short,
+                                            description=description or "",
+                                            server=client.server_name,
+                                            available=available).model_dump())
+
+                        # Sort tools_info by name to maintain consistent ordering
+                        tools_info.sort(key=lambda x: x['name'])
+
+                        mcp_clients_info.append({
+                            "function_group": group_name,
+                            "server": client.server_name,
+                            "transport": config.server.transport,
+                            "session_healthy": session_healthy,
+                            "tools": tools_info,
+                            "total_tools": len(configured_short_names),
+                            "available_tools": available_count
+                        })
+
+                    except Exception as e:
+                        logger.error(f"Error processing MCP client {group_name}: {e}")
+                        mcp_clients_info.append({
+                            "function_group": group_name,
+                            "server": "unknown",
+                            "transport": config.server.transport if config.server else "unknown",
+                            "session_healthy": False,
+                            "error": str(e),
+                            "tools": [],
+                            "total_tools": 0,
+                            "workflow_tools": 0
+                        })
+
+                return MCPClientToolListResponse(mcp_clients=mcp_clients_info)
+
+            except Exception as e:
+                logger.error(f"Error in MCP client tool list endpoint: {e}")
+                raise HTTPException(status_code=500, detail=f"Failed to retrieve MCP client information: {str(e)}")
+
+        # Add the route to the FastAPI app
+        app.add_api_route(
+            path="/mcp/client/tool/list",
+            endpoint=get_mcp_client_tool_list,
+            methods=["GET"],
+            response_model=MCPClientToolListResponse,
+            description="Get list of MCP client tools with session health and workflow configuration comparison",
+            responses={
+                200: {
+                    "description": "Successfully retrieved MCP client tool information",
+                    "content": {
+                        "application/json": {
+                            "example": {
+                                "mcp_clients": [{
+                                    "function_group": "mcp_tools",
+                                    "server": "streamable-http:http://localhost:9901/mcp",
+                                    "transport": "streamable-http",
+                                    "session_healthy": True,
+                                    "tools": [{
+                                        "name": "tool_a",
+                                        "description": "Tool A description",
+                                        "server": "streamable-http:http://localhost:9901/mcp",
+                                        "available": True
+                                    }],
+                                    "total_tools": 1,
+                                    "available_tools": 1
+                                }]
+                            }
+                        }
+                    }
+                },
+                500: {
+                    "description": "Internal Server Error"
+                }
+            })
+
     async def _add_flow(self, state: str, flow_state: FlowState):
         async with self._outstanding_flows_lock:
             self._outstanding_flows[state] = flow_state

nat/front_ends/fastapi/job_store.py

@@ -370,7 +370,7 @@ class JobStore(DaskClientMixin):
                 # Convert BaseModel to JSON string for storage
                 output = output.model_dump_json(round_trip=True)
 
-            if isinstance(output, (dict, list)):
+            if isinstance(output, dict | list):
                 # Convert dict or list to JSON string for storage
                 output = json.dumps(output)
 
@@ -555,7 +555,7 @@ class JobStore(DaskClientMixin):
                         logger.exception("Failed to expire %s", job_id)
 
                 await session.execute(
-                    (update(JobInfo).where(JobInfo.job_id.in_(successfully_expired)).values(is_expired=True)))
+                    update(JobInfo).where(JobInfo.job_id.in_(successfully_expired)).values(is_expired=True))
 
 
 def get_db_engine(db_url: str | None = None, echo: bool = False, use_async: bool = True) -> "Engine | AsyncEngine":

nat/front_ends/fastapi/message_handler.py

@@ -105,10 +105,10 @@ class WebSocketMessageHandler:
                 if (isinstance(validated_message, WebSocketUserMessage)):
                     await self.process_workflow_request(validated_message)
 
-                elif isinstance(validated_message,
-                                (WebSocketSystemResponseTokenMessage,
-                                 WebSocketSystemIntermediateStepMessage,
-                                 WebSocketSystemInteractionMessage)):
+                elif isinstance(
+                        validated_message,
+                        WebSocketSystemResponseTokenMessage | WebSocketSystemIntermediateStepMessage
+                        | WebSocketSystemInteractionMessage):
                     # These messages are already handled by self.create_websocket_message(data_model=value, …)
                     # No further processing is needed here.
                     pass

nat/front_ends/fastapi/message_validator.py

@@ -139,7 +139,7 @@ class MessageValidator:
                     text_content: str = str(data_model.payload)
                 validated_message_content = SystemResponseContent(text=text_content)
 
-            elif (isinstance(data_model, (ChatResponse, ChatResponseChunk))):
+            elif (isinstance(data_model, ChatResponse | ChatResponseChunk)):
                 validated_message_content = SystemResponseContent(text=data_model.choices[0].message.content)
 
             elif (isinstance(data_model, ResponseIntermediateStep)):
@@ -204,7 +204,7 @@ class MessageValidator:
 
         validated_message_type: str = ""
         try:
-            if (isinstance(data_model, (ResponsePayloadOutput, ChatResponse, ChatResponseChunk))):
+            if (isinstance(data_model, ResponsePayloadOutput | ChatResponse | ChatResponseChunk)):
                 validated_message_type = WebSocketMessageType.RESPONSE_MESSAGE
 
             elif (isinstance(data_model, ResponseIntermediateStep)):
@@ -241,7 +241,7 @@ class MessageValidator:
         content: SystemResponseContent
         | Error = SystemResponseContent(),
         status: WebSocketMessageStatus = WebSocketMessageStatus.IN_PROGRESS,
-        timestamp: str = str(datetime.datetime.now(datetime.timezone.utc))
+        timestamp: str = str(datetime.datetime.now(datetime.UTC))
     ) -> WebSocketSystemResponseTokenMessage | None:
         """
         Creates a system response token message with default values.
@@ -280,7 +280,7 @@ class MessageValidator:
         conversation_id: str | None = None,
         content: SystemIntermediateStepContent = SystemIntermediateStepContent(name="default", payload="default"),
         status: WebSocketMessageStatus = WebSocketMessageStatus.IN_PROGRESS,
-        timestamp: str = str(datetime.datetime.now(datetime.timezone.utc))
+        timestamp: str = str(datetime.datetime.now(datetime.UTC))
     ) -> WebSocketSystemIntermediateStepMessage | None:
         """
         Creates a system intermediate step message with default values.
@@ -320,7 +320,7 @@ class MessageValidator:
         conversation_id: str | None = None,
         content: HumanPrompt,
         status: WebSocketMessageStatus = WebSocketMessageStatus.IN_PROGRESS,
-        timestamp: str = str(datetime.datetime.now(datetime.timezone.utc))
+        timestamp: str = str(datetime.datetime.now(datetime.UTC))
     ) -> WebSocketSystemInteractionMessage | None:
         """
         Creates a system interaction message with default values.

nat/front_ends/mcp/tool_converter.py

@@ -175,7 +175,7 @@ def create_function_wrapper(
                 # Handle different result types for proper formatting
                 if isinstance(result, str):
                     return result
-                if isinstance(result, (dict, list)):
+                if isinstance(result, dict | list):
                     return json.dumps(result, default=str)
                 return str(result)
             except Exception as e:

nat/llm/utils/thinking.py

@@ -19,10 +19,10 @@ import logging
 import types
 from abc import abstractmethod
 from collections.abc import AsyncGenerator
+from collections.abc import Callable
 from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Any
-from typing import Callable
 from typing import TypeVar
 
 ModelType = TypeVar("ModelType")

nat/observability/exporter/base_exporter.py

@@ -372,7 +372,7 @@ class BaseExporter(Exporter):
         try:
             # Wait for all tasks to complete with a timeout
             await asyncio.wait_for(asyncio.gather(*self._tasks, return_exceptions=True), timeout=timeout)
-        except asyncio.TimeoutError:
+        except TimeoutError:
             logger.warning("%s: Some tasks did not complete within %s seconds", self.name, timeout)
         except Exception as e:
             logger.exception("%s: Error while waiting for tasks: %s", self.name, e)

nat/observability/exporter/span_exporter.py

@@ -252,7 +252,7 @@ class SpanExporter(ProcessingExporter[InputSpanT, OutputSpanT], SerializeMixin):
 
         end_metadata = event.payload.metadata or {}
 
-        if not isinstance(end_metadata, (dict, TraceMetadata)):
+        if not isinstance(end_metadata, dict | TraceMetadata):
             logger.warning("Invalid metadata type for step %s", event.UUID)
             return
 

nat/observability/exporter_manager.py

@@ -184,7 +184,7 @@ class ExporterManager:
             try:
                 await asyncio.wait_for(asyncio.gather(*cleanup_tasks, return_exceptions=True),
                                        timeout=self._shutdown_timeout)
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.warning("Some isolated exporters did not clean up within timeout")
 
         self._active_isolated_exporters.clear()
@@ -301,7 +301,7 @@ class ExporterManager:
             try:
                 task.cancel()
                 await asyncio.wait_for(task, timeout=self._shutdown_timeout)
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.warning("Exporter '%s' task did not shut down in time and may be stuck.", name)
                 stuck_tasks.append(name)
             except asyncio.CancelledError:

nat/observability/processor/batching_processor.py

@@ -241,7 +241,7 @@ class BatchingProcessor(CallbackProcessor[T, list[T]], Generic[T]):
             try:
                 await asyncio.wait_for(self._shutdown_complete_event.wait(), timeout=self._shutdown_timeout)
                 logger.debug("Shutdown completion detected via event")
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 logger.warning("Shutdown completion timeout exceeded (%s seconds)", self._shutdown_timeout)
             return
 

nat/profiler/decorators/function_tracking.py

@@ -40,10 +40,10 @@ def _serialize_data(obj: Any) -> Any:
 
     if isinstance(obj, dict):
         return {str(k): _serialize_data(v) for k, v in obj.items()}
-    if isinstance(obj, (list, tuple, set)):
+    if isinstance(obj, list | tuple | set):
         return [_serialize_data(item) for item in obj]
 
-    if isinstance(obj, (str, int, float, bool, type(None))):
+    if isinstance(obj, str | int | float | bool | type(None)):
         return obj
 
     # Fallback

nat/profiler/parameter_optimization/parameter_selection.py

@@ -13,8 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 import optuna
@@ -41,8 +40,8 @@ def pick_trial(
     study: Study,
     mode: str = "harmonic",
     *,
-    weights: Optional[Sequence[float]] = None,
-    ref_point: Optional[Sequence[float]] = None,
+    weights: Sequence[float] | None = None,
+    ref_point: Sequence[float] | None = None,
     eps: float = 1e-12,
 ) -> optuna.trial.FrozenTrial:
     """

nat/profiler/parameter_optimization/pareto_visualizer.py

@@ -324,7 +324,7 @@ def create_pareto_visualization(data_source: optuna.Study | Path | pd.DataFrame,
     if hasattr(data_source, 'trials_dataframe'):
         # Optuna study object
         trials_df, pareto_trials_df = load_trials_from_study(data_source)
-    elif isinstance(data_source, (str, Path)):
+    elif isinstance(data_source, str | Path):
         # CSV file path
         trials_df, pareto_trials_df = load_trials_from_csv(Path(data_source), metric_names, directions)
     elif isinstance(data_source, pd.DataFrame):

nat/retriever/milvus/retriever.py

@@ -214,7 +214,7 @@ def _wrap_milvus_results(res: list[Hit], content_field: str):
 
 
 def _wrap_milvus_single_results(res: Hit | dict, content_field: str) -> Document:
-    if not isinstance(res, (Hit, dict)):
+    if not isinstance(res, Hit | dict):
         raise ValueError(f"Milvus search returned object of type {type(res)}. Expected 'Hit' or 'dict'.")
 
     if isinstance(res, Hit):

nat/settings/global_settings.py

@@ -124,7 +124,7 @@ class Settings(HashableBaseModel):
                 if (short_names[key.local_name] == 1):
                     type_list.append((key.local_name, key.config_type))
 
-            return typing.Union[tuple(typing.Annotated[x_type, Tag(x_id)] for x_id, x_type in type_list)]
+            return typing.Union[*tuple(typing.Annotated[x_type, Tag(x_id)] for x_id, x_type in type_list)]
 
         RegistryHandlerAnnotation = dict[
             str,
@@ -169,7 +169,7 @@ class Settings(HashableBaseModel):
         if (not os.path.exists(configuration_file)):
             loaded_config = {}
         else:
-            with open(file_path, mode="r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 try:
                     loaded_config = json.load(f)
                 except Exception as e:

nat/tool/code_execution/local_sandbox/local_sandbox_server.py

@@ -62,7 +62,7 @@ class CodeExecutionResponse(Response):
         super().__init__(status=status_code, mimetype="application/json", response=result.model_dump_json())
 
     @classmethod
-    def with_error(cls, status_code: int, error_message: str) -> 'CodeExecutionResponse':
+    def with_error(cls, status_code: int, error_message: str) -> CodeExecutionResponse:
         return cls(status_code,
                    CodeExecutionResult(process_status=CodeExecutionStatus.ERROR, stdout="", stderr=error_message))
 

nat/tool/datetime_tools.py

@@ -72,7 +72,7 @@ async def current_datetime(_config: CurrentTimeToolConfig, _builder: Builder):
         timezone_obj = _get_timezone_obj(headers)
 
         now = datetime.datetime.now(timezone_obj)
-        now_machine_readable = now.strftime(("%Y-%m-%d %H:%M:%S %z"))
+        now_machine_readable = now.strftime("%Y-%m-%d %H:%M:%S %z")
 
         # Returns the current time in machine readable format with timezone offset.
         return f"The current time of day is {now_machine_readable}"

nat/utils/data_models/schema_validator.py

@@ -52,7 +52,7 @@ def validate_yaml(ctx, param, value):
     if value is None:
         return None
 
-    with open(value, 'r', encoding="utf-8") as f:
+    with open(value, encoding="utf-8") as f:
         yaml.safe_load(f)
 
     return value

nat/utils/exception_handlers/automatic_retries.py

@@ -310,7 +310,7 @@ def patch_with_retry(
         descriptor = inspect.getattr_static(cls, name)
 
         # Skip dunders, privates and all descriptors we must not wrap
-        if (name.startswith("_") or isinstance(descriptor, (property, staticmethod, classmethod))):
+        if (name.startswith("_") or isinstance(descriptor, property | staticmethod | classmethod)):
             continue
 
         original = descriptor.__func__ if isinstance(descriptor, types.MethodType) else descriptor

nat/utils/io/yaml_tools.py

@@ -57,7 +57,7 @@ def yaml_load(config_path: StrPath) -> dict:
     """
 
     # Read YAML file
-    with open(config_path, "r", encoding="utf-8") as stream:
+    with open(config_path, encoding="utf-8") as stream:
         config_str = stream.read()
 
     return yaml_loads(config_str)

nat/utils/type_utils.py

@@ -250,7 +250,7 @@ class DecomposedType:
         remaining_args = tuple(arg for arg in self.args if arg is not types.NoneType)
 
         if (len(remaining_args) > 1):
-            return DecomposedType(typing.Union[remaining_args])
+            return DecomposedType(typing.Union[*remaining_args])
         if (len(remaining_args) == 1):
             return DecomposedType(remaining_args[0])
 

{nvidia_nat-1.3.0a20250928.dist-info → nvidia_nat-1.3.0a20250930.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.3.0a20250928
+Version: 1.3.0a20250930
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -232,6 +232,7 @@ Requires-Dist: numpy~=2.3; python_version >= "3.12"
 Requires-Dist: openinference-semantic-conventions~=0.1.14
 Requires-Dist: openpyxl~=3.1
 Requires-Dist: optuna~=4.4.0
+Requires-Dist: pip>=24.3.1
 Requires-Dist: pkce==1.0.3
 Requires-Dist: pkginfo~=1.12
 Requires-Dist: platformdirs~=4.3