Improve tool response serialization

Author: contextablemark

typescript-sdk/integrations/adk-middleware/python/src/ag_ui_adk/event_translator.py

@@ -2,6 +2,8 @@
 
 """Event translator for converting ADK events to AG-UI protocol events."""
 
+import dataclasses
+from collections.abc import Iterable, Mapping
 from typing import AsyncGenerator, Optional, Dict, Any , List
 import uuid
 
@@ -21,6 +23,106 @@
 logger = logging.getLogger(__name__)
 
 
+def _coerce_tool_response(value: Any, _visited: Optional[set[int]] = None) -> Any:
+    """Recursively convert arbitrary tool responses into JSON-serializable structures."""
+
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        try:
+            return value.decode()  # type: ignore[union-attr]
+        except Exception:
+            return list(value)
+
+    if _visited is None:
+        _visited = set()
+
+    obj_id = id(value)
+    if obj_id in _visited:
+        return str(value)
+
+    _visited.add(obj_id)
+    try:
+        if dataclasses.is_dataclass(value) and not isinstance(value, type):
+            return {
+                field.name: _coerce_tool_response(getattr(value, field.name), _visited)
+                for field in dataclasses.fields(value)
+            }
+
+        if hasattr(value, "_asdict") and callable(getattr(value, "_asdict")):
+            try:
+                return {
+                    str(k): _coerce_tool_response(v, _visited)
+                    for k, v in value._asdict().items()  # type: ignore[attr-defined]
+                }
+            except Exception:
+                pass
+
+        for method_name in ("model_dump", "to_dict"):
+            method = getattr(value, method_name, None)
+            if callable(method):
+                try:
+                    dumped = method()
+                except TypeError:
+                    try:
+                        dumped = method(exclude_none=False)
+                    except Exception:
+                        continue
+                except Exception:
+                    continue
+
+                return _coerce_tool_response(dumped, _visited)
+
+        if isinstance(value, Mapping):
+            return {
+                str(k): _coerce_tool_response(v, _visited)
+                for k, v in value.items()
+            }
+
+        if isinstance(value, (list, tuple, set, frozenset)):
+            return [_coerce_tool_response(item, _visited) for item in value]
+
+        if isinstance(value, Iterable):
+            try:
+                return [_coerce_tool_response(item, _visited) for item in list(value)]
+            except TypeError:
+                pass
+
+        try:
+            obj_vars = vars(value)
+        except TypeError:
+            obj_vars = None
+
+        if obj_vars:
+            coerced = {
+                key: _coerce_tool_response(val, _visited)
+                for key, val in obj_vars.items()
+                if not key.startswith("_")
+            }
+            if coerced:
+                return coerced
+
+        return str(value)
+    finally:
+        _visited.discard(obj_id)
+
+
+def _serialize_tool_response(response: Any) -> str:
+    """Serialize a tool response into a JSON string."""
+
+    try:
+        coerced = _coerce_tool_response(response)
+        return json.dumps(coerced, ensure_ascii=False)
+    except Exception as exc:
+        logger.warning("Failed to coerce tool response to JSON: %s", exc, exc_info=True)
+        try:
+            return json.dumps(str(response), ensure_ascii=False)
+        except Exception:
+            logger.warning("Failed to stringify tool response; returning empty string.")
+            return json.dumps("", ensure_ascii=False)
+
+
 class EventTranslator:
     """Translates Google ADK events to AG-UI protocol events.
     
@@ -377,7 +479,7 @@ async def _translate_function_response(
                     message_id=str(uuid.uuid4()),
                     type=EventType.TOOL_CALL_RESULT,
                     tool_call_id=tool_call_id,
-                    content=json.dumps(func_response.response)
+                    content=_serialize_tool_response(func_response.response)
                 )
             else:
                 logger.debug(f"Skipping ToolCallResultEvent for long-running tool: {tool_call_id}")