fix(tools): support zero-argument nodes in NodeTool

A FunctionNode taking no arguments (or only a context parameter) no longer
fails with "does not have an input_schema defined" -- it now omits
parameters_json_schema from its FunctionDeclaration, matching FunctionTool.

Co-authored-by: Shangjie Chen <deanchen@google.com>
PiperOrigin-RevId: 974086964

Author: DeanChensj

src/google/adk/tools/_node_tool.py

@@ -66,7 +66,11 @@ def __init__(
       if orig_output_schema is not None:
         node.output_schema = orig_output_schema
 
-    if not getattr(node, 'input_schema', None):
+    # A FunctionNode has already inferred its schema by here, and that yields
+    # None only when the function has nothing to bind.
+    if not isinstance(node, FunctionNode) and not getattr(
+        node, 'input_schema', None
+    ):
       raise ValueError(
           f"Node '{node.name}' does not have an input_schema defined."
           ' NodeTool requires an explicit Pydantic input_schema on the wrapped'
@@ -84,26 +88,27 @@ def __init__(
 
   @override
   def _get_declaration(self) -> types.FunctionDeclaration:
-    schema = schema_to_json_schema(self.node.input_schema)
-
-    # The GenAI API strictly requires parameters_json_schema to be an 'object'
-    # type schema. If the node has a primitive input schema (e.g., str, int),
-    # we wrap it into an object schema with a 'request' property.
-    if isinstance(schema, dict) and schema.get('type') != 'object':
-      schema = {
-          'type': 'object',
-          'properties': {
-              'request': schema,
-          },
-          'required': ['request'],
-      }
-
     decl = types.FunctionDeclaration(
         name=self.name,
         description=self.description,
-        parameters_json_schema=schema,
     )
 
+    input_schema = getattr(self.node, 'input_schema', None)
+    if input_schema is not None:
+      schema = schema_to_json_schema(input_schema)
+      # The GenAI API strictly requires parameters_json_schema to be an 'object'
+      # type schema. If the node has a primitive input schema (e.g., str, int),
+      # we wrap it into an object schema with a 'request' property.
+      if isinstance(schema, dict) and schema.get('type') != 'object':
+        schema = {
+            'type': 'object',
+            'properties': {
+                'request': schema,
+            },
+            'required': ['request'],
+        }
+      decl.parameters_json_schema = schema
+
     output_schema = getattr(self.node, 'output_schema', None)
     if output_schema:
       decl.response_json_schema = schema_to_json_schema(output_schema)
@@ -121,7 +126,7 @@ async def run_async(
 
     from pydantic import BaseModel
 
-    input_schema = self.node.input_schema
+    input_schema = getattr(self.node, 'input_schema', None)
     node_input: Any
     if inspect.isclass(input_schema) and issubclass(input_schema, BaseModel):
       try:
@@ -130,7 +135,11 @@ async def run_async(
       except Exception as e:
         return f'Error validating input for node: {e}'
     else:
-      schema = schema_to_json_schema(input_schema)
+      schema = (
+          schema_to_json_schema(input_schema)
+          if input_schema is not None
+          else None
+      )
       if isinstance(schema, dict) and schema.get('type') != 'object':
         node_input = args.get('request')
       else:

tests/unittests/workflow/test_node_tool.py

@@ -1072,3 +1072,61 @@ def echo_func(node_input: str):
   assert func_response_events[0].content.parts[
       0
   ].function_response.response == {'result': 'Echo: hello_world'}
+
+
+@pytest.mark.parametrize('has_context', [False, True])
+@pytest.mark.asyncio
+async def test_node_tool_wraps_zero_argument_function(
+    request: pytest.FixtureRequest,
+    has_context: bool,
+):
+  """NodeTool supports FunctionNode taking no arguments or only context."""
+
+  if has_context:
+
+    @node
+    def get_constant(ctx: Context) -> str:
+      """Returns a constant value."""
+      return 'constant_val'
+
+  else:
+
+    @node
+    def get_constant() -> str:
+      """Returns a constant value."""
+      return 'constant_val'
+
+  tool = NodeTool(node=get_constant)
+  decl = tool._get_declaration()
+  assert decl.name == 'get_constant'
+  assert decl.parameters_json_schema is None
+
+  parent_agent = LlmAgent(
+      name='parent_agent',
+      model=testing_utils.MockModel.create(
+          responses=[
+              types.Part.from_function_call(
+                  name='get_constant',
+                  args={},
+              ),
+              types.Part.from_text(text='Finished.'),
+          ]
+      ),
+      tools=[get_constant],
+  )
+  app = App(
+      name=f'{request.function.__name__}_{has_context}',
+      root_agent=parent_agent,
+  )
+  runner = testing_utils.InMemoryRunner(app=app)
+  events = await runner.run_async(testing_utils.get_user_content('Run'))
+
+  func_response_events = [
+      e
+      for e in events
+      if e.content and e.content.parts and e.content.parts[0].function_response
+  ]
+  assert len(func_response_events) == 1
+  assert func_response_events[0].content.parts[
+      0
+  ].function_response.response == {'result': 'constant_val'}