fix(agent_tool): only apply ReAct wrapper when output_schema is not set

- Fix: only apply the ReAct wrapper in agent_tool.py when output_schema is not set on the inner agent, preventing breaking of single-shot structured output mode
- Add regression test test_run_async_with_input_and_output_schema_passes_raw_json documenting that raw JSON is passed when both input_schema and output_schema are set
- Apply pre-commit formatting fixes (isort + pyink)

Author: ecanlar

src/google/adk/tools/agent_tool.py

@@ -218,19 +218,29 @@ async def run_async(
     if input_schema:
       input_value = input_schema.model_validate(args)
       json_payload = input_value.model_dump_json(exclude_none=True)
-      content = types.Content(
-          role='user',
-          parts=[
-              types.Part.from_text(
-                  text=(
-                      'Process the following structured request. Use your'
-                      ' available tools as needed to gather information or'
-                      ' perform actions before producing the final'
-                      ' response.\n\nRequest:\n' + json_payload
-                  )
-              )
-          ],
-      )
+      output_schema = _get_output_schema(self.agent)
+      if output_schema:
+        # Single-shot structured output mode: pass raw JSON, no ReAct wrapper.
+        content = types.Content(
+            role='user',
+            parts=[types.Part.from_text(text=json_payload)],
+        )
+      else:
+        # Tool-calling mode: wrap with ReAct-style prompt.
+        content = types.Content(
+            role='user',
+            parts=[
+                types.Part.from_text(
+                    text=(
+                        'Process the following structured request. Use your'
+                        ' available tools as needed to gather information or'
+                        ' perform actions before producing the final'
+                        ' response.\n\nRequest:\n'
+                        + json_payload
+                    )
+                )
+            ],
+        )
     else:
       content = types.Content(
           role='user',

tests/unittests/models/test_litellm.py

@@ -4999,9 +4999,7 @@ async def test_get_completion_inputs_tool_choice_none_without_tool_config():
   """tool_choice must be None when no tool_config is present."""
   llm_request = LlmRequest(
       contents=[
-          types.Content(
-              role="user", parts=[types.Part.from_text(text="Hello")]
-          )
+          types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
       ],
   )
 
@@ -5017,9 +5015,7 @@ async def test_get_completion_inputs_tool_choice_required_for_any_mode():
   """tool_choice must be 'required' when mode=ANY."""
   llm_request = LlmRequest(
       contents=[
-          types.Content(
-              role="user", parts=[types.Part.from_text(text="Hello")]
-          )
+          types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
       ],
       config=types.GenerateContentConfig(
           tool_config=types.ToolConfig(
@@ -5042,9 +5038,7 @@ async def test_get_completion_inputs_tool_choice_none_for_none_mode():
   """tool_choice must be 'none' when mode=NONE."""
   llm_request = LlmRequest(
       contents=[
-          types.Content(
-              role="user", parts=[types.Part.from_text(text="Hello")]
-          )
+          types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
       ],
       config=types.GenerateContentConfig(
           tool_config=types.ToolConfig(
@@ -5067,9 +5061,7 @@ async def test_get_completion_inputs_tool_choice_none_for_auto_mode():
   """tool_choice must be None (provider default) when mode=AUTO."""
   llm_request = LlmRequest(
       contents=[
-          types.Content(
-              role="user", parts=[types.Part.from_text(text="Hello")]
-          )
+          types.Content(role="user", parts=[types.Part.from_text(text="Hello")])
       ],
       config=types.GenerateContentConfig(
           tool_config=types.ToolConfig(
@@ -5159,9 +5151,7 @@ async def test_generate_content_async_omits_tool_choice_for_auto_mode(
 
   llm_request = LlmRequest(
       contents=[
-          types.Content(
-              role="user", parts=[types.Part.from_text(text="Hi")]
-          )
+          types.Content(role="user", parts=[types.Part.from_text(text="Hi")])
       ],
       config=types.GenerateContentConfig(
           tool_config=types.ToolConfig(
@@ -5190,9 +5180,7 @@ async def test_generate_content_async_omits_tool_choice_without_tool_config(
 
   llm_request = LlmRequest(
       contents=[
-          types.Content(
-              role="user", parts=[types.Part.from_text(text="Hi")]
-          )
+          types.Content(role="user", parts=[types.Part.from_text(text="Hi")])
       ],
   )
 

tests/unittests/tools/test_agent_tool.py

@@ -1441,15 +1441,17 @@ def test_empty_sequential_agent_falls_back_to_request(self):
 async def _run_agent_tool_and_capture_content(
     args: dict,
     input_schema=None,
+    output_schema=None,
 ) -> types.Content:
   """Drives AgentTool and captures the Content passed to the inner agent.
 
   This uses a stub Runner (same pattern as test_agent_tool_inherits_parent_app_name)
   to intercept the new_message without executing the actual agent pipeline.
   """
+  from unittest.mock import patch
+
   from google.adk.agents.llm_agent import LlmAgent
   from google.adk.plugins.plugin_manager import PluginManager
-  from unittest.mock import patch
   import google.adk.runners as _runners_module
 
   if input_schema is not None:
@@ -1458,6 +1460,7 @@ async def _run_agent_tool_and_capture_content(
         description='captures input',
         model=testing_utils.MockModel.create(responses=['done']),
         input_schema=input_schema,
+        output_schema=output_schema,
     )
   else:
     inner = Agent(name='inner_agent', model='test-model')
@@ -1470,16 +1473,33 @@ async def _empty_async_generator():
 
   class _StubRunner:
 
-    def __init__(self, *, app_name, agent, artifact_service,
-                 session_service, memory_service, credential_service, plugins):
+    def __init__(
+        self,
+        *,
+        app_name,
+        agent,
+        artifact_service,
+        session_service,
+        memory_service,
+        credential_service,
+        plugins,
+    ):
       del artifact_service, memory_service, credential_service
       self.agent = agent
       self.session_service = session_service
       self.plugin_manager = PluginManager(plugins=plugins)
       self.app_name = app_name
 
-    def run_async(self, *, user_id, session_id, invocation_id=None,
-                  new_message=None, state_delta=None, run_config=None):
+    def run_async(
+        self,
+        *,
+        user_id,
+        session_id,
+        invocation_id=None,
+        new_message=None,
+        state_delta=None,
+        run_config=None,
+    ):
       new_message_holder.append(new_message)
       return _empty_async_generator()
 
@@ -1538,6 +1558,7 @@ class MyInput(BaseModel):
   assert 'Request:\n' in text
   json_part = text.split('Request:\n', 1)[1]
   import json as _json
+
   payload = _json.loads(json_part)
   assert payload['custom_input'] == 'test_value'
   # The full text must NOT be just the raw JSON blob
@@ -1559,6 +1580,60 @@ class MyInput(BaseModel):
   assert content is not None
   text = content.parts[0].text
   # A bare JSON blob would start with '{'; the wrapped version must not
-  assert not text.startswith('{'), (
-      'Content text is raw JSON instead of a natural-language instruction'
+  assert not text.startswith(
+      '{'
+  ), 'Content text is raw JSON instead of a natural-language instruction'
+
+
+@mark.asyncio
+async def test_run_async_with_input_and_output_schema_passes_raw_json():
+  """With both input_schema AND output_schema, the raw JSON payload is passed
+  directly to the inner runner WITHOUT the ReAct wrapper prefix.
+
+  The wrapper ('Process the following structured request...') is only added
+  when input_schema is set and output_schema is NOT set (tool-calling mode).
+  When output_schema is also present the agent operates in single-shot
+  structured-output mode, so the runner receives the bare JSON string that the
+  inner agent can parse deterministically — adding the prose prefix would
+  corrupt the structured input.
+  """
+  import json as _json
+
+  class MyInput(BaseModel):
+    query: str
+    limit: int
+
+  class MyOutput(BaseModel):
+    result: str
+
+  content = await _run_agent_tool_and_capture_content(
+      args={'query': 'hello', 'limit': 5},
+      input_schema=MyInput,
+      output_schema=MyOutput,
   )
+
+  assert content is not None
+  assert len(content.parts) == 1
+  text = content.parts[0].text
+
+  # output_schema mode is single-shot; wrapper must not be applied
+  assert not text.startswith('Process'), (
+      'output_schema mode is single-shot; wrapper must not be applied,'
+      f' but text starts with: {text[:60]!r}'
+  )
+
+  # The payload must be valid JSON
+  try:
+    payload = _json.loads(text)
+  except _json.JSONDecodeError as exc:
+    raise AssertionError(
+        f'Content text is not valid JSON in output_schema mode: {text!r}'
+    ) from exc
+
+  # The JSON must match the input args
+  assert (
+      payload['query'] == 'hello'
+  ), f"Expected query='hello', got {payload.get('query')!r}"
+  assert (
+      payload['limit'] == 5
+  ), f"Expected limit=5, got {payload.get('limit')!r}"