fix(google-adk): cap before_tool args + review test coverage (page 6)

Follow-up to the #362 review pass — the earlier commit covered AgentTool walk,
_stringify cap, cached-agent rebind, trace_id drop, and the cap warning; these
are the rest of page 6:

- callbacks.py:249 (Major) — before_tool no longer passes tool args uncapped.
  New _cap_args bounds the payload: within budget the dict passes through
  unchanged (per-key rules still work); once its serialized size exceeds the
  cap it is replaced with a single capped {"_truncated": ...}. Contrast with
  after_tool, which already capped its result.
- test_callbacks.py (Minor) — the tree test now also asserts the container
  agent is NOT decorated; added a huge-args cap test. (Double-attach with a
  pre-existing user callback is already covered by
  test_install_governance_preserves_existing_callback_and_runs_first.)

Acknowledged, unchanged (flagged as follow-ups):
- callbacks sync-only (Major): making governance async is a protocol-wide
  change (the evaluator is sync) — deferred, not one-off here.
- _session_state accumulation across cached-agent reuse (Minor): fixed by the
  rebind added in the earlier commit (rebind resets the counters). Per-task
  safety for ParallelAgent's concurrent callbacks is a known limitation.
- LIFO cap ordering (Minor): the cap now logs; which nodes are dropped past
  the cap is non-deterministic but all found nodes are governed.

Tests: 66 pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: aditik0303

packages/uipath-google-adk/src/uipath_google_adk/governance/callbacks.py

@@ -331,7 +331,7 @@ def before_tool(self, tool: Any, args: Dict[str, Any], tool_context: Any) -> Non
             tool_name = getattr(tool, "name", None) or "unknown"
             self._evaluator.evaluate_tool_call(
                 tool_name=tool_name,
-                tool_args=args or {},
+                tool_args=self._cap_args(args or {}),
                 agent_name=self._agent_name,
                 runtime_id=self._session_id,
                 session_state=self._session_state,
@@ -458,6 +458,24 @@ def _part_text(cls, part: Any) -> str:
 
         return "\n".join(p for p in pieces if p)
 
+    @classmethod
+    def _cap_args(cls, args: Dict[str, Any], cap: int = _BEFORE_MODEL_TEXT_CAP) -> Any:
+        """Bound the tool-args payload before it reaches the evaluator.
+
+        ``before_tool`` receives args straight from ADK; a huge blob (e.g. a
+        tool called with a multi-megabyte string) would otherwise be scanned
+        uncapped — contrast with ``after_tool``, which caps its result. Within
+        budget the dict is passed through unchanged (so per-key rules still
+        work); once its serialized size exceeds ``cap`` it is replaced with a
+        single capped, stringified form.
+        """
+        if not isinstance(args, dict) or not args:
+            return args
+        blob = cls._stringify(args, cap + 1)
+        if len(blob) <= cap:
+            return args
+        return {"_truncated": blob[:cap]}
+
     @staticmethod
     def _stringify(value: Any, cap: int = _BEFORE_MODEL_TEXT_CAP) -> str:
         """Render a dict / object payload as compact, scannable text, capped.

packages/uipath-google-adk/tests/governance/test_callbacks.py

@@ -137,6 +137,8 @@ def test_install_governance_installs_on_all_llm_agents_in_tree():
         assert len(leaf.before_model_callback) == 1
         assert leaf.after_model_callback and leaf.before_tool_callback
         assert leaf.after_tool_callback
+    # the container agent has no model-callback surface → must NOT be decorated
+    assert not hasattr(root, "before_model_callback")
 
 
 def test_install_governance_is_idempotent():
@@ -350,6 +352,18 @@ def test_before_tool_passes_args_and_session_state():
     assert kwargs["session_state"]["tool_calls"] == 1
 
 
+def test_before_tool_caps_huge_args():
+    """A huge arg blob must not reach the evaluator uncapped (contrast with the
+    small-args case, which passes through unchanged)."""
+    ev = FakeEvaluator()
+    cb = _make_callbacks(ev)
+    huge = "x" * (_BEFORE_MODEL_TEXT_CAP + 5000)
+    cb.before_tool(FakeTool("t"), {"blob": huge}, tool_context=None)
+    tool_args = ev.calls[-1][1]["tool_args"]
+    assert set(tool_args) == {"_truncated"}
+    assert len(tool_args["_truncated"]) <= _BEFORE_MODEL_TEXT_CAP
+
+
 def test_after_tool_stringifies_dict_response():
     ev = FakeEvaluator()
     cb = _make_callbacks(ev)