fix(builder): an entry function two groups offer is ambiguous; document group functions as entry points

Signed-off-by: Somay-kousis <somaykaush@gmail.com>

Author: Somay-kousis

docs/source/build-workflows/functions-and-function-groups/function-groups.md

@@ -458,6 +458,8 @@ function_groups:
 | `include: [add]`      | ✓ (all functions)           | ✓ (only `add`)      | ✓ (only `add`)              |
 | `exclude: [divide]`   | ✓ (all functions)           | ✗                   | ✓ (except `divide`)         |
 
+A function that is available as an agent tool can also be the entry point of a workflow, even when it is not in the global registry. For example, `nat mcp serve` publishes each of them as an MCP tool, and a FastAPI endpoint can name one in `function_name`.
+
 ## Using Function Groups
 
 ### Creating Custom Function Groups

packages/nvidia_nat_core/src/nat/builder/per_user_workflow_builder.py

@@ -703,7 +703,7 @@ async def build(self, entry_function: str | None = None) -> Workflow:
                 entry_fn_obj = await self.get_function(entry_function)
             except ValueError:
                 entry_fn_obj = await _find_function_group_function(
-                    self._check_backwards_compatibility_function_name(entry_function),
+                    entry_function,
                     [*self._per_user_function_groups.values(), *self._shared_builder._function_groups.values()])
                 if entry_fn_obj is None:
                     raise

packages/nvidia_nat_core/src/nat/builder/workflow_builder.py

@@ -191,11 +191,15 @@ class ConfiguredTrajectoryBuilder:
 
 async def _find_function_group_function(name: str, function_groups: list[ConfiguredFunctionGroup]) -> Function | None:
     """A function one of the groups makes available as a tool (`group__fn`), even if it isn't globally registered."""
+    matches = []
     for function_group in function_groups:
         accessible_functions = await function_group.instance.get_accessible_functions()
         if name in accessible_functions:
-            return accessible_functions[name]
-    return None
+            matches.append(accessible_functions[name])
+    if len(matches) > 1:
+        # e.g. group `a` with function `b__c` and group `a__b` with function `c`
+        raise ValueError(f"Function `{name}` is ambiguous: more than one function group makes it available")
+    return matches[0] if matches else None
 
 
 def _log_build_failure(component_name: str,
@@ -717,8 +721,7 @@ async def _get_entry_function(self, name: str) -> Function:
         try:
             return await self.get_function(name)
         except ValueError:
-            group_function = await _find_function_group_function(
-                self._check_backwards_compatibility_function_name(name), list(self._function_groups.values()))
+            group_function = await _find_function_group_function(name, list(self._function_groups.values()))
             if group_function is None:
                 raise
             return group_function