fix(tools): accept dict output_schema in SetModelResponseTool (#5469)

Merge #5516

## Summary

Fixes #5469. When `output_schema` is a raw dict (e.g. `{"type": "object", "properties": {...}}`), `SetModelResponseTool.__init__` previously fell through to the generic `else` branch and used the dict **instance** as the parameter annotation. Downstream, `_function_parameter_parse_util._is_builtin_primitive_or_compound` does `annotation in _py_builtin_type_to_schema_type.keys()`, which calls `__hash__` on the annotation and raises `TypeError: unhashable type: 'dict'`.

This change adds an explicit `elif isinstance(output_schema, dict)` branch that uses the `dict` type (hashable) as the annotation, so the existing builtin lookup maps it to `Type.OBJECT` cleanly. `run_async` already handles this case via the existing `args.get('response')` pass-through.

## Reproduction (before fix)

```python
from google.adk.agents import Agent

agent = Agent(
    name="test",
    model="gemini-2.5-flash",
    instruction="You are a helpful agent.",
    output_schema={"type": "object", "properties": {"result": {"type": "string"}}},
)
# -> TypeError: unhashable type: 'dict'
```

## Testing plan

- Added regression unit tests in `tests/unittests/tools/test_set_model_response_tool.py`:
  - `test_tool_initialization_raw_dict_schema` — `__init__` with a raw dict does not crash and stores the schema.
  - `test_function_signature_generation_raw_dict_schema` — generated signature has a single `response: dict` parameter (annotation is the `dict` type, not the dict instance).
  - `test_get_declaration_raw_dict_schema` — `_get_declaration()` returns a valid declaration without raising `TypeError`.
  - `test_run_async_raw_dict_schema` — `run_async` returns the response unchanged.
- Run: `pytest tests/unittests/tools/test_set_model_response_tool.py -q`
- Existing tests for `BaseModel`, `list[BaseModel]`, `list[str]`, `dict[str, int]` schemas remain unchanged and still pass.

## Notes

- Schema fidelity (propagating dict-schema constraints into the function declaration) is intentionally out of scope; this PR only fixes the crash, matching the issue's reported scope and the existing handling for `list[str]` / `dict[str, int]`.

Co-authored-by: Xuan Yang <xygoogle@google.com>
COPYBARA_INTEGRATE_REVIEW=#5516 from MukundaKatta:fix/set-model-response-tool-dict-schema 5e808a9
PiperOrigin-RevId: 941169611

Author: 2 people

src/google/adk/tools/set_model_response_tool.py

@@ -52,6 +52,10 @@ def __init__(self, output_schema: SchemaType):
         - dict: Raw dict schemas
         - Schema: Google's Schema type
     """
+    # Convert types.Schema instance to raw dict to avoid unhashable crash
+    if isinstance(output_schema, types.Schema):
+      output_schema = output_schema.model_dump(exclude_none=True)
+
     self.output_schema = output_schema
     self._is_basemodel = is_basemodel_schema(output_schema)
     self._is_list_of_basemodel = is_list_of_basemodel(output_schema)
@@ -87,8 +91,22 @@ def set_model_response() -> str:
               annotation=list[inner_type],
           )
       ]
+    elif isinstance(output_schema, dict):
+      # For raw dict schemas (e.g. {"type": "object", "properties": {...}}),
+      # use the `dict` type itself as the annotation rather than the dict
+      # instance. Passing the instance would later trigger
+      # `annotation in _py_builtin_type_to_schema_type.keys()` inside
+      # `_function_parameter_parse_util`, which calls `__hash__` on the
+      # annotation and raises `TypeError: unhashable type: 'dict'`.
+      params = [
+          inspect.Parameter(
+              'response',
+              inspect.Parameter.KEYWORD_ONLY,
+              annotation=dict,
+          )
+      ]
     else:
-      # For other schema types (list[str], dict, etc.),
+      # For other schema types (list[str], dict[str, int], etc.),
       # create a single parameter with the actual schema type
       params = [
           inspect.Parameter(

tests/unittests/tools/test_set_model_response_tool.py

@@ -25,6 +25,7 @@
 from google.adk.sessions.in_memory_session_service import InMemorySessionService
 from google.adk.tools.set_model_response_tool import SetModelResponseTool
 from google.adk.tools.tool_context import ToolContext
+from google.genai import types
 from pydantic import BaseModel
 from pydantic import Field
 from pydantic import ValidationError
@@ -472,6 +473,105 @@ async def test_run_async_dict_schema():
   assert result == {'a': 1, 'b': 2, 'c': 3}
 
 
+def test_tool_initialization_raw_dict_schema():
+  """Raw dict output_schema must not crash and must be stored as-is."""
+  raw_schema = {
+      'type': 'object',
+      'properties': {'result': {'type': 'string'}},
+  }
+
+  tool = SetModelResponseTool(raw_schema)
+
+  assert tool.output_schema == raw_schema
+  assert not tool._is_basemodel
+  assert not tool._is_list_of_basemodel
+  assert tool.name == 'set_model_response'
+  assert tool.func is not None
+
+
+def test_function_signature_generation_raw_dict_schema():
+  """Raw dict schemas should produce a single `response: dict` parameter.
+
+  The annotation must be the `dict` type (hashable), not the dict instance,
+  so downstream `_is_builtin_primitive_or_compound` does not raise
+  `TypeError: unhashable type: 'dict'`.
+  """
+  raw_schema = {
+      'type': 'object',
+      'properties': {'result': {'type': 'string'}},
+  }
+
+  tool = SetModelResponseTool(raw_schema)
+
+  sig = inspect.signature(tool.func)
+
+  assert 'response' in sig.parameters
+  assert len(sig.parameters) == 1
+  assert sig.parameters['response'].kind == inspect.Parameter.KEYWORD_ONLY
+  # The annotation is the hashable `dict` type, not the dict instance.
+  assert sig.parameters['response'].annotation is dict
+
+
+def test_get_declaration_raw_dict_schema():
+  """`_get_declaration` must not raise when given a raw dict schema."""
+  raw_schema = {
+      'type': 'object',
+      'properties': {'result': {'type': 'string'}},
+  }
+
+  tool = SetModelResponseTool(raw_schema)
+
+  declaration = tool._get_declaration()
+
+  assert declaration is not None
+  assert declaration.name == 'set_model_response'
+  assert declaration.description is not None
+
+
+@pytest.mark.asyncio
+async def test_run_async_raw_dict_schema():
+  """Tool execution with a raw dict schema returns the response unchanged."""
+  raw_schema = {
+      'type': 'object',
+      'properties': {'result': {'type': 'string'}},
+  }
+  tool = SetModelResponseTool(raw_schema)
+
+  agent = LlmAgent(name='test_agent', model='gemini-1.5-flash')
+  invocation_context = await _create_invocation_context(agent)
+  tool_context = ToolContext(invocation_context)
+
+  result = await tool.run_async(
+      args={'response': {'result': 'hello'}},
+      tool_context=tool_context,
+  )
+
+  assert result == {'result': 'hello'}
+
+
+def test_tool_initialization_schema_instance():
+  """types.Schema instance output_schema must be converted to dict and not crash."""
+  schema_instance = types.Schema(
+      type=types.Type.OBJECT,
+      properties={'result': types.Schema(type=types.Type.STRING)},
+  )
+
+  tool = SetModelResponseTool(schema_instance)
+
+  # Check that it converted it to a dictionary
+  assert isinstance(tool.output_schema, dict)
+  assert 'result' in tool.output_schema['properties']
+
+  sig = inspect.signature(tool.func)
+  assert 'response' in sig.parameters
+  assert sig.parameters['response'].annotation is dict
+
+  # Check that get_declaration works and doesn't crash with TypeError
+  declaration = tool._get_declaration()
+  assert declaration is not None
+  assert declaration.name == 'set_model_response'
+
+
 class SubSchema(BaseModel):
 
   field1: str = Field(description='Field 1')