fix: strip markdown code fences before validating output_schema JSON

A model configured with both tools and an output_schema cannot be
hard-constrained to emit pure JSON, so it occasionally wraps the structured
output in a markdown code fence. Unwrap a fully-fenced payload in
validate_schema, the shared entry point for the classic, workflow, and
agent-as-tool output paths. Well-formed JSON never starts with a fence, so
this is a no-op on valid input.

Co-authored-by: George Weale <gweale@google.com>
PiperOrigin-RevId: 949192652

Author: GWeale

src/google/adk/utils/_schema_utils.py

@@ -21,6 +21,7 @@
 from __future__ import annotations
 
 import json
+import re
 from typing import Any
 from typing import get_args
 from typing import get_origin
@@ -106,6 +107,19 @@ def schema_to_json_schema(schema: SchemaType) -> dict[str, Any]:
   return TypeAdapter(schema).json_schema()
 
 
+def _strip_json_code_fence(json_text: str) -> str:
+  """Removes a markdown code fence wrapping the entire JSON payload, if present.
+
+  A model asked for structured output occasionally wraps it in a
+  ```json ... ``` fence, most often when tools are configured alongside an
+  output schema and the schema constraint becomes best-effort. Well-formed JSON
+  never starts with a fence, so this is a no-op on valid input.
+  """
+  stripped = json_text.strip()
+  match = re.fullmatch(r"```\w*\s*(.*?)\s*```", stripped, re.DOTALL)
+  return match.group(1).strip() if match else json_text
+
+
 def validate_schema(schema: SchemaType, json_text: str) -> Any:
   """Validate JSON text against a schema and return the result.
 
@@ -119,6 +133,8 @@ def validate_schema(schema: SchemaType, json_text: str) -> Any:
       - list of dicts for list[BaseModel]
       - raw value for other schema types (list[str], dict, etc.)
   """
+  json_text = _strip_json_code_fence(json_text)
+
   if is_basemodel_schema(schema):
     # For regular BaseModel, use model_validate_json
     return schema.model_validate_json(json_text).model_dump(exclude_none=True)

tests/unittests/utils/test_schema_utils.py

@@ -149,6 +149,54 @@ def test_dict_schema(self):
     result = validate_schema(dict[str, int], json_text)
     assert result == {'key1': 1, 'key2': 2}
 
+  def test_json_code_fence_is_stripped(self):
+    """Test that a ```json fenced payload is unwrapped before validation."""
+    json_text = '```json\n{"name": "test", "value": 42}\n```'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': 'test', 'value': 42}
+
+  def test_uppercase_json_code_fence_is_stripped(self):
+    """Test that an uppercase language tag is not left in the payload."""
+    json_text = '```JSON\n{"name": "test", "value": 42}\n```'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': 'test', 'value': 42}
+
+  def test_other_language_tag_code_fence_is_stripped(self):
+    """Test that any language tag on the fence is unwrapped."""
+    json_text = '```python\n{"name": "test", "value": 42}\n```'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': 'test', 'value': 42}
+
+  def test_bare_code_fence_is_stripped(self):
+    """Test that a fence without a language tag is unwrapped."""
+    json_text = '```\n{"name": "test", "value": 42}\n```'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': 'test', 'value': 42}
+
+  def test_code_fence_with_surrounding_whitespace_is_stripped(self):
+    """Test that whitespace around the fence does not break unwrapping."""
+    json_text = '  \n```json\n{"name": "test", "value": 42}\n```  \n'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': 'test', 'value': 42}
+
+  def test_list_schema_code_fence_is_stripped(self):
+    """Test that a fenced list[BaseModel] payload is unwrapped."""
+    json_text = '```json\n[{"name": "item1", "value": 1}]\n```'
+    result = validate_schema(list[SampleModel], json_text)
+    assert result == [{'name': 'item1', 'value': 1}]
+
+  def test_plain_json_is_unaffected(self):
+    """Test that unfenced JSON is validated unchanged."""
+    json_text = '{"name": "test", "value": 42}'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': 'test', 'value': 42}
+
+  def test_backticks_inside_value_are_preserved(self):
+    """Test that triple backticks inside a valid JSON value are not stripped."""
+    json_text = '{"name": "```", "value": 42}'
+    result = validate_schema(SampleModel, json_text)
+    assert result == {'name': '```', 'value': 42}
+
 
 class TestValidateNodeData:
   """Tests for validate_node_data function."""