nvidia-nat 1.3.0a20250829__py3-none-any.whl → 1.3.0a20250830__py3-none-any.whl

nat/agent/react_agent/agent.py

@@ -77,7 +77,8 @@ class ReActAgentGraph(DualNodeAgent):
                  retry_agent_response_parsing_errors: bool = True,
                  parse_agent_response_max_retries: int = 1,
                  tool_call_max_retries: int = 1,
-                 pass_tool_call_errors_to_agent: bool = True):
+                 pass_tool_call_errors_to_agent: bool = True,
+                 normalize_tool_input_quotes: bool = True):
         super().__init__(llm=llm,
                          tools=tools,
                          callbacks=callbacks,
@@ -87,6 +88,7 @@ class ReActAgentGraph(DualNodeAgent):
                                                  if retry_agent_response_parsing_errors else 1)
         self.tool_call_max_retries = tool_call_max_retries
         self.pass_tool_call_errors_to_agent = pass_tool_call_errors_to_agent
+        self.normalize_tool_input_quotes = normalize_tool_input_quotes
         logger.debug(
             "%s Filling the prompt variables 'tools' and 'tool_names', using the tools provided in the config.",
             AGENT_LOG_PREFIX)
@@ -286,35 +288,45 @@ class ReActAgentGraph(DualNodeAgent):
                      agent_thoughts.tool_input)
 
         # Run the tool. Try to use structured input, if possible.
+        tool_input_str = agent_thoughts.tool_input.strip()
+
         try:
-            tool_input_str = str(agent_thoughts.tool_input).strip().replace("'", '"')
-            tool_input_dict = json.loads(tool_input_str) if tool_input_str != 'None' else tool_input_str
+            tool_input = json.loads(tool_input_str) if tool_input_str != 'None' else tool_input_str
             logger.debug("%s Successfully parsed structured tool input from Action Input", AGENT_LOG_PREFIX)
 
-            tool_response = await self._call_tool(requested_tool,
-                                                  tool_input_dict,
-                                                  RunnableConfig(callbacks=self.callbacks),
-                                                  max_retries=self.tool_call_max_retries)
-
-            if self.detailed_logs:
-                self._log_tool_response(requested_tool.name, tool_input_dict, str(tool_response.content))
-
-        except JSONDecodeError as ex:
-            logger.debug(
-                "%s Unable to parse structured tool input from Action Input. Using Action Input as is."
-                "\nParsing error: %s",
-                AGENT_LOG_PREFIX,
-                ex,
-                exc_info=True)
-            tool_input_str = str(agent_thoughts.tool_input)
-
-            tool_response = await self._call_tool(requested_tool,
-                                                  tool_input_str,
-                                                  RunnableConfig(callbacks=self.callbacks),
-                                                  max_retries=self.tool_call_max_retries)
+        except JSONDecodeError as original_ex:
+            if self.normalize_tool_input_quotes:
+                # If initial JSON parsing fails, try with quote normalization as a fallback
+                normalized_str = tool_input_str.replace("'", '"')
+                try:
+                    tool_input = json.loads(normalized_str)
+                    logger.debug("%s Successfully parsed structured tool input after quote normalization",
+                                 AGENT_LOG_PREFIX)
+                except JSONDecodeError:
+                    # the quote normalization failed, use raw string input
+                    logger.debug(
+                        "%s Unable to parse structured tool input after quote normalization. Using Action Input as is."
+                        "\nParsing error: %s",
+                        AGENT_LOG_PREFIX,
+                        original_ex)
+                    tool_input = tool_input_str
+            else:
+                # use raw string input
+                logger.debug(
+                    "%s Unable to parse structured tool input from Action Input. Using Action Input as is."
+                    "\nParsing error: %s",
+                    AGENT_LOG_PREFIX,
+                    original_ex)
+                tool_input = tool_input_str
+
+        # Call tool once with the determined input (either parsed dict or raw string)
+        tool_response = await self._call_tool(requested_tool,
+                                              tool_input,
+                                              RunnableConfig(callbacks=self.callbacks),
+                                              max_retries=self.tool_call_max_retries)
 
         if self.detailed_logs:
-            self._log_tool_response(requested_tool.name, tool_input_str, str(tool_response.content))
+            self._log_tool_response(requested_tool.name, tool_input, str(tool_response.content))
 
         if not self.pass_tool_call_errors_to_agent:
             if tool_response.status == "error":

nat/agent/react_agent/register.py

@@ -62,6 +62,10 @@ class ReActAgentWorkflowConfig(FunctionBaseConfig, name="react_agent"):
     include_tool_input_schema_in_tool_description: bool = Field(
         default=True, description="Specify inclusion of tool input schemas in the prompt.")
     description: str = Field(default="ReAct Agent Workflow", description="The description of this functions use.")
+    normalize_tool_input_quotes: bool = Field(
+        default=True,
+        description="Whether to replace single quotes with double quotes in the tool input. "
+        "This is useful for tools that expect structured json input.")
     system_prompt: str | None = Field(
         default=None,
         description="Provides the SYSTEM_PROMPT to use with the agent")  # defaults to SYSTEM_PROMPT in prompt.py
@@ -107,7 +111,8 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
         retry_agent_response_parsing_errors=config.retry_agent_response_parsing_errors,
         parse_agent_response_max_retries=config.parse_agent_response_max_retries,
         tool_call_max_retries=config.tool_call_max_retries,
-        pass_tool_call_errors_to_agent=config.pass_tool_call_errors_to_agent).build_graph()
+        pass_tool_call_errors_to_agent=config.pass_tool_call_errors_to_agent,
+        normalize_tool_input_quotes=config.normalize_tool_input_quotes).build_graph()
 
     async def _response_fn(input_message: ChatRequest) -> ChatResponse:
         try:

nat/builder/workflow.py

@@ -84,7 +84,11 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
         return self._entry_fn.has_single_output
 
     async def get_all_exporters(self) -> dict[str, BaseExporter]:
-        return await self._exporter_manager.get_all_exporters()
+        return await self.exporter_manager.get_all_exporters()
+
+    @property
+    def exporter_manager(self) -> ExporterManager:
+        return self._exporter_manager.get()
 
     @asynccontextmanager
     async def run(self, message: InputT):
@@ -96,7 +100,7 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
         async with Runner(input_message=message,
                           entry_fn=self._entry_fn,
                           context_state=self._context_state,
-                          exporter_manager=self._exporter_manager.get()) as runner:
+                          exporter_manager=self.exporter_manager) as runner:
 
             # The caller can `yield runner` so they can do `runner.result()` or `runner.result_stream()`
             yield runner

nat/cli/commands/info/list_mcp.py

@@ -23,14 +23,36 @@ import click
 from pydantic import BaseModel
 
 from nat.tool.mcp.exceptions import MCPError
-from nat.tool.mcp.mcp_client import MCPBuilder
 from nat.utils.exception_handlers.mcp import format_mcp_error
 
 # Suppress verbose logs from mcp.client.sse and httpx
 logging.getLogger("mcp.client.sse").setLevel(logging.WARNING)
 logging.getLogger("httpx").setLevel(logging.WARNING)
 
-logger = logging.getLogger(__name__)
+
+def validate_transport_cli_args(transport: str, command: str | None, args: str | None, env: str | None) -> bool:
+    """
+    Validate transport and parameter combinations, returning False if invalid.
+
+    Args:
+        transport: The transport type ('sse', 'stdio', or 'streamable-http')
+        command: Command for stdio transport
+        args: Arguments for stdio transport
+        env: Environment variables for stdio transport
+
+    Returns:
+        bool: True if valid, False if invalid (error message already displayed)
+    """
+    if transport == 'stdio':
+        if not command:
+            click.echo("--command is required when using stdio client type", err=True)
+            return False
+    elif transport in ['sse', 'streamable-http']:
+        if command or args or env:
+            click.echo("--command, --args, and --env are not allowed when using sse or streamable-http client type",
+                       err=True)
+            return False
+    return True
 
 
 class MCPPingResult(BaseModel):
@@ -64,12 +86,20 @@ def format_tool(tool: Any) -> dict[str, str | None]:
     description = getattr(tool, 'description', '')
     input_schema = getattr(tool, 'input_schema', None) or getattr(tool, 'inputSchema', None)
 
-    schema_str = None
-    if input_schema:
-        if hasattr(input_schema, "schema_json"):
-            schema_str = input_schema.schema_json(indent=2)
-        else:
-            schema_str = str(input_schema)
+    # Normalize schema to JSON string
+    if input_schema is None:
+        return {
+            "name": name,
+            "description": description,
+            "input_schema": None,
+        }
+    elif hasattr(input_schema, "schema_json"):
+        schema_str = input_schema.schema_json(indent=2)
+    elif isinstance(input_schema, dict):
+        schema_str = json.dumps(input_schema, indent=2)
+    else:
+        # Final fallback: attempt to dump stringified version wrapped as JSON string
+        schema_str = json.dumps({"raw": str(input_schema)}, indent=2)
 
     return {
         "name": name,
@@ -100,8 +130,8 @@ def print_tool(tool_dict: dict[str, str | None], detail: bool = False) -> None:
         click.echo("-" * 60)
 
 
-async def list_tools_and_schemas(url: str, tool_name: str | None = None) -> list[dict[str, str | None]]:
-    """List MCP tools using MCPBuilder with structured exception handling.
+async def list_tools_and_schemas(command, url, tool_name=None, transport='sse', args=None, env=None):
+    """List MCP tools using NAT MCPClient with structured exception handling.
 
     Args:
         url (str): MCP server URL to connect to
@@ -115,20 +145,35 @@ async def list_tools_and_schemas(url: str, tool_name: str | None = None) -> list
     Raises:
         MCPError: Caught internally and logged, returns empty list instead
     """
-    builder = MCPBuilder(url=url)
+    from nat.tool.mcp.mcp_client_base import MCPSSEClient
+    from nat.tool.mcp.mcp_client_base import MCPStdioClient
+    from nat.tool.mcp.mcp_client_base import MCPStreamableHTTPClient
+
+    if args is None:
+        args = []
+
     try:
-        if tool_name:
-            tool = await builder.get_tool(tool_name)
-            return [format_tool(tool)]
-        tools = await builder.get_tools()
-        return [format_tool(tool) for tool in tools.values()]
+        if transport == 'stdio':
+            client = MCPStdioClient(command=command, args=args, env=env)
+        elif transport == 'streamable-http':
+            client = MCPStreamableHTTPClient(url=url)
+        else:  # sse
+            client = MCPSSEClient(url=url)
+
+        async with client:
+            if tool_name:
+                tool = await client.get_tool(tool_name)
+                return [format_tool(tool)]
+            else:
+                tools = await client.get_tools()
+                return [format_tool(tool) for tool in tools.values()]
     except MCPError as e:
         format_mcp_error(e, include_traceback=False)
         return []
 
 
-async def list_tools_direct(url: str, tool_name: str | None = None) -> list[dict[str, str | None]]:
-    """List MCP tools using direct MCP protocol with exception conversion.
+async def list_tools_direct(command, url, tool_name=None, transport='sse', args=None, env=None):
+    """List MCP tools using direct MCP protocol with structured exception handling.
 
     Bypasses MCPBuilder and uses raw MCP ClientSession and SSE client directly.
     Converts raw exceptions to structured MCPErrors for consistent user experience.
@@ -147,25 +192,51 @@ async def list_tools_direct(url: str, tool_name: str | None = None) -> list[dict
         This function handles ExceptionGroup by extracting the most relevant exception
         and converting it to MCPError for consistent error reporting.
     """
+    if args is None:
+        args = []
     from mcp import ClientSession
     from mcp.client.sse import sse_client
+    from mcp.client.stdio import StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    from mcp.client.streamable_http import streamablehttp_client
 
     try:
-        async with sse_client(url=url) as (read, write):
+        if transport == 'stdio':
+
+            def get_stdio_client():
+                return stdio_client(server=StdioServerParameters(command=command, args=args, env=env))
+
+            client = get_stdio_client
+        elif transport == 'streamable-http':
+
+            def get_streamable_http_client():
+                return streamablehttp_client(url=url)
+
+            client = get_streamable_http_client
+        else:
+
+            def get_sse_client():
+                return sse_client(url=url)
+
+            client = get_sse_client
+
+        async with client() as ctx:
+            read, write = (ctx[0], ctx[1]) if isinstance(ctx, tuple) else ctx
             async with ClientSession(read, write) as session:
                 await session.initialize()
                 response = await session.list_tools()
 
-                tools = []
-                for tool in response.tools:
-                    if tool_name:
-                        if tool.name == tool_name:
-                            return [format_tool(tool)]
-                    else:
-                        tools.append(format_tool(tool))
-                if tool_name and not tools:
-                    click.echo(f"[INFO] Tool '{tool_name}' not found.")
-                return tools
+        tools = []
+        for tool in response.tools:
+            if tool_name:
+                if tool.name == tool_name:
+                    tools.append(format_tool(tool))
+            else:
+                tools.append(format_tool(tool))
+
+        if tool_name and not tools:
+            click.echo(f"[INFO] Tool '{tool_name}' not found.")
+        return tools
     except Exception as e:
         # Convert raw exceptions to structured MCPError for consistency
         from nat.utils.exception_handlers.mcp import convert_to_mcp_error
@@ -181,7 +252,12 @@ async def list_tools_direct(url: str, tool_name: str | None = None) -> list[dict
         return []
 
 
-async def ping_mcp_server(url: str, timeout: int) -> MCPPingResult:
+async def ping_mcp_server(url: str,
+                          timeout: int,
+                          transport: str = 'streamable-http',
+                          command: str | None = None,
+                          args: list[str] | None = None,
+                          env: dict[str, str] | None = None) -> MCPPingResult:
     """Ping an MCP server to check if it's responsive.
 
     Args:
@@ -193,18 +269,29 @@ async def ping_mcp_server(url: str, timeout: int) -> MCPPingResult:
     """
     from mcp.client.session import ClientSession
     from mcp.client.sse import sse_client
+    from mcp.client.stdio import StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    from mcp.client.streamable_http import streamablehttp_client
 
     async def _ping_operation():
-        async with sse_client(url) as (read, write):
+        # Select transport
+        if transport == 'stdio':
+            stdio_args_local: list[str] = args or []
+            if not command:
+                raise RuntimeError("--command is required for stdio transport")
+            client_ctx = stdio_client(server=StdioServerParameters(command=command, args=stdio_args_local, env=env))
+        elif transport == 'sse':
+            client_ctx = sse_client(url)
+        else:  # streamable-http
+            client_ctx = streamablehttp_client(url=url)
+
+        async with client_ctx as ctx:
+            read, write = (ctx[0], ctx[1]) if isinstance(ctx, tuple) else ctx
             async with ClientSession(read, write) as session:
-                # Initialize the session
                 await session.initialize()
 
-                # Record start time just before ping
                 start_time = time.time()
-                # Send ping request
                 await session.send_ping()
-
                 end_time = time.time()
                 response_time_ms = round((end_time - start_time) * 1000, 2)
 
@@ -226,12 +313,24 @@ async def ping_mcp_server(url: str, timeout: int) -> MCPPingResult:
 
 @click.group(invoke_without_command=True, help="List tool names (default), or show details with --detail or --tool.")
 @click.option('--direct', is_flag=True, help='Bypass MCPBuilder and use direct MCP protocol')
-@click.option('--url', default='http://localhost:9901/sse', show_default=True, help='MCP server URL')
+@click.option(
+    '--url',
+    default='http://localhost:9901/mcp',
+    show_default=True,
+    help='MCP server URL (e.g. http://localhost:8080/mcp for streamable-http, http://localhost:8080/sse for sse)')
+@click.option('--transport',
+              type=click.Choice(['sse', 'stdio', 'streamable-http']),
+              default='streamable-http',
+              show_default=True,
+              help='Type of client to use (default: streamable-http, backwards compatible with sse)')
+@click.option('--command', help='For stdio: The command to run (e.g. mcp-server)')
+@click.option('--args', help='For stdio: Additional arguments for the command (space-separated)')
+@click.option('--env', help='For stdio: Environment variables in KEY=VALUE format (space-separated)')
 @click.option('--tool', default=None, help='Get details for a specific tool by name')
 @click.option('--detail', is_flag=True, help='Show full details for all tools')
 @click.option('--json-output', is_flag=True, help='Output tool metadata in JSON format')
 @click.pass_context
-def list_mcp(ctx: click.Context, direct: bool, url: str, tool: str | None, detail: bool, json_output: bool) -> None:
+def list_mcp(ctx, direct, url, transport, command, args, env, tool, detail, json_output):
     """List MCP tool names (default) or show detailed tool information.
 
     Use --detail for full output including descriptions and input schemas.
@@ -242,7 +341,7 @@ def list_mcp(ctx: click.Context, direct: bool, url: str, tool: str | None, detai
     Args:
         ctx (click.Context): Click context object for command invocation
         direct (bool): Whether to bypass MCPBuilder and use direct MCP protocol
-        url (str): MCP server URL to connect to (default: http://localhost:9901/sse)
+        url (str): MCP server URL to connect to (default: http://localhost:9901/mcp)
         tool (str | None): Optional specific tool name to retrieve detailed info for
         detail (bool): Whether to show full details (description + schema) for all tools
         json_output (bool): Whether to output tool metadata in JSON format instead of text
@@ -256,44 +355,81 @@ def list_mcp(ctx: click.Context, direct: bool, url: str, tool: str | None, detai
     """
     if ctx.invoked_subcommand is not None:
         return
+
+    if not validate_transport_cli_args(transport, command, args, env):
+        return
+
+    if transport in ['sse', 'streamable-http']:
+        if not url:
+            click.echo("[ERROR] --url is required when using sse or streamable-http client type", err=True)
+            return
+
+    stdio_args = args.split() if args else []
+    stdio_env = dict(var.split('=', 1) for var in env.split()) if env else None
+
     fetcher = list_tools_direct if direct else list_tools_and_schemas
-    tools = asyncio.run(fetcher(url, tool))
+    tools = asyncio.run(fetcher(command, url, tool, transport, stdio_args, stdio_env))
 
     if json_output:
         click.echo(json.dumps(tools, indent=2))
     elif tool:
-        for tool_dict in tools:
+        for tool_dict in (tools or []):
             print_tool(tool_dict, detail=True)
     elif detail:
-        for tool_dict in tools:
+        for tool_dict in (tools or []):
             print_tool(tool_dict, detail=True)
     else:
-        for tool_dict in tools:
+        for tool_dict in (tools or []):
             click.echo(tool_dict.get('name', 'Unknown tool'))
 
 
 @list_mcp.command()
-@click.option('--url', default='http://localhost:9901/sse', show_default=True, help='MCP server URL')
+@click.option(
+    '--url',
+    default='http://localhost:9901/mcp',
+    show_default=True,
+    help='MCP server URL (e.g. http://localhost:8080/mcp for streamable-http, http://localhost:8080/sse for sse)')
+@click.option('--transport',
+              type=click.Choice(['sse', 'stdio', 'streamable-http']),
+              default='streamable-http',
+              show_default=True,
+              help='Type of client to use for ping')
+@click.option('--command', help='For stdio: The command to run (e.g. mcp-server)')
+@click.option('--args', help='For stdio: Additional arguments for the command (space-separated)')
+@click.option('--env', help='For stdio: Environment variables in KEY=VALUE format (space-separated)')
 @click.option('--timeout', default=60, show_default=True, help='Timeout in seconds for ping request')
 @click.option('--json-output', is_flag=True, help='Output ping result in JSON format')
-def ping(url: str, timeout: int, json_output: bool) -> None:
+def ping(url: str,
+         transport: str,
+         command: str | None,
+         args: str | None,
+         env: str | None,
+         timeout: int,
+         json_output: bool) -> None:
     """Ping an MCP server to check if it's responsive.
 
     This command sends a ping request to the MCP server and measures the response time.
     It's useful for health checks and monitoring server availability.
 
     Args:
-        url (str): MCP server URL to ping (default: http://localhost:9901/sse)
+        url (str): MCP server URL to ping (default: http://localhost:9901/mcp)
         timeout (int): Timeout in seconds for the ping request (default: 60)
         json_output (bool): Whether to output the result in JSON format
 
     Examples:
         nat info mcp ping                                    # Ping default server
-        nat info mcp ping --url http://custom-server:9901/sse # Ping custom server
+        nat info mcp ping --url http://custom-server:9901/mcp # Ping custom server
         nat info mcp ping --timeout 10                      # Use 10 second timeout
         nat info mcp ping --json-output                     # Get JSON format output
     """
-    result = asyncio.run(ping_mcp_server(url, timeout))
+    # Validate combinations similar to parent command
+    if not validate_transport_cli_args(transport, command, args, env):
+        return
+
+    stdio_args = args.split() if args else []
+    stdio_env = dict(var.split('=', 1) for var in env.split()) if env else None
+
+    result = asyncio.run(ping_mcp_server(url, timeout, transport, command, stdio_args, stdio_env))
 
     if json_output:
         click.echo(result.model_dump_json(indent=2))

nat/cli/commands/start.py

@@ -102,12 +102,24 @@ class StartCommandGroup(click.Group):
                 raise ValueError(f"Invalid field '{name}'.Unions are only supported for optional parameters.")
 
             # Handle the types
-            if (issubclass(decomposed_type.root, Path)):
+            # Literal[...] -> map to click.Choice([...])
+            if (decomposed_type.origin is typing.Literal):
+                # typing.get_args returns the literal values; ensure they are strings for Click
+                literal_values = [str(v) for v in decomposed_type.args]
+                param_type = click.Choice(literal_values)
+
+            elif (issubclass(decomposed_type.root, Path)):
                 param_type = click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path)
 
             elif (issubclass(decomposed_type.root, (list, tuple, set))):
                 if (len(decomposed_type.args) == 1):
-                    param_type = decomposed_type.args[0]
+                    inner = DecomposedType(decomposed_type.args[0])
+                    # Support containers of Literal values -> multiple Choice
+                    if (inner.origin is typing.Literal):
+                        literal_values = [str(v) for v in inner.args]
+                        param_type = click.Choice(literal_values)
+                    else:
+                        param_type = inner.root
                 else:
                     param_type = None
 

nat/data_models/thinking_mixin.py

@@ -22,8 +22,7 @@ from nat.data_models.gated_field_mixin import GatedFieldMixin
 
 # The system prompt format for thinking is different for these, so we need to distinguish them here with two separate
 # regex patterns
-_NVIDIA_NEMOTRON_REGEX = re.compile(r"^nvidia/nvidia.*nemotron", re.IGNORECASE)
-_LLAMA_NEMOTRON_REGEX = re.compile(r"^nvidia/llama.*nemotron", re.IGNORECASE)
+_NEMOTRON_REGEX = re.compile(r"^nvidia/(llama|nvidia).*nemotron", re.IGNORECASE)
 _MODEL_KEYS = ("model_name", "model", "azure_deployment")
 
 
@@ -33,7 +32,7 @@ class ThinkingMixin(
         field_name="thinking",
         default_if_supported=None,
         keys=_MODEL_KEYS,
-        supported=(_NVIDIA_NEMOTRON_REGEX, _LLAMA_NEMOTRON_REGEX),
+        supported=(_NEMOTRON_REGEX, ),
 ):
     """
     Mixin class for thinking configuration. Only supported on Nemotron models.
@@ -52,7 +51,8 @@ class ThinkingMixin(
         """
         Returns the system prompt to use for thinking.
         For NVIDIA Nemotron, returns "/think" if enabled, else "/no_think".
-        For Llama Nemotron, returns "detailed thinking on" if enabled, else "detailed thinking off".
+        For Llama Nemotron v1.5, returns "/think" if enabled, else "/no_think".
+        For Llama Nemotron v1.0, returns "detailed thinking on" if enabled, else "detailed thinking off".
         If thinking is not supported on the model, returns None.
 
         Returns:
@@ -60,9 +60,28 @@ class ThinkingMixin(
         """
         if self.thinking is None:
             return None
+
         for key in _MODEL_KEYS:
-            if hasattr(self, key):
-                if _NVIDIA_NEMOTRON_REGEX.match(getattr(self, key)):
-                    return "/think" if self.thinking else "/no_think"
-                elif _LLAMA_NEMOTRON_REGEX.match(getattr(self, key)):
+            model = getattr(self, key, None)
+            if not isinstance(model, str) or model is None:
+                continue
+
+            # Normalize name to reduce checks
+            model = model.lower().translate(str.maketrans("_.", "--"))
+
+            if model.startswith("nvidia/nvidia"):
+                return "/think" if self.thinking else "/no_think"
+
+            if model.startswith("nvidia/llama"):
+                if "v1-0" in model or "v1-1" in model:
                     return f"detailed thinking {'on' if self.thinking else 'off'}"
+
+                if "v1-5" in model:
+                    # v1.5 models are updated to use the /think and /no_think system prompts
+                    return "/think" if self.thinking else "/no_think"
+
+                # Assume any other model is a newer model that uses the /think and /no_think system prompts
+                return "/think" if self.thinking else "/no_think"
+
+        # Unknown model
+        return None

nat/front_ends/mcp/mcp_front_end_config.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Literal
+
 from pydantic import Field
 
 from nat.data_models.front_end import FrontEndBaseConfig
@@ -32,5 +34,8 @@ class MCPFrontEndConfig(FrontEndBaseConfig, name="mcp"):
     log_level: str = Field(default="INFO", description="Log level for the MCP server (default: INFO)")
     tool_names: list[str] = Field(default_factory=list,
                                   description="The list of tools MCP server will expose (default: all tools)")
+    transport: Literal["sse", "streamable-http"] = Field(
+        default="streamable-http",
+        description="Transport type for the MCP server (default: streamable-http, backwards compatible with sse)")
     runner_class: str | None = Field(
         default=None, description="Custom worker class for handling MCP routes (default: built-in worker)")

nat/front_ends/mcp/mcp_front_end_plugin.py

@@ -77,5 +77,11 @@ class MCPFrontEndPlugin(FrontEndBase[MCPFrontEndConfig]):
             # Add routes through the worker (includes health endpoint and function registration)
             await worker.add_routes(mcp, builder)
 
-            # Start the MCP server
-            await mcp.run_sse_async()
+            # Start the MCP server with configurable transport
+            # streamable-http is the default, but users can choose sse if preferred
+            if self.front_end_config.transport == "sse":
+                logger.info("Starting MCP server with SSE endpoint at /sse")
+                await mcp.run_sse_async()
+            else:  # streamable-http
+                logger.info("Starting MCP server with streamable-http endpoint at /mcp/")
+                await mcp.run_streamable_http_async()

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -134,9 +134,9 @@ class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
                     logger.debug("Skipping function %s as it's not in tool_names", function_name)
             functions = filtered_functions
 
-        # Register each function with MCP
+        # Register each function with MCP, passing workflow context for observability
         for function_name, function in functions.items():
-            register_function_with_mcp(mcp, function_name, function)
+            register_function_with_mcp(mcp, function_name, function, workflow)
 
         # Add a simple fallback function if no functions were found
         if not functions: