feat: include thoughts and tool calls in compaction summaries

Port of GitHub PR: bdb5582

The compaction summarizer fed only message text to the LLM, dropping agent thoughts and tool calls/responses. Include them, skip a prior compaction's own thought, and reiterate the user request in the default prompt to reduce drift.

Co-authored-by: Yifan Wang <wanyif@google.com>
PiperOrigin-RevId: 927437249

Author: wyf7107

src/google/adk/apps/llm_event_summarizer.py

@@ -47,13 +47,19 @@ class LlmEventSummarizer(BaseEventsSummarizer):
   """
 
   _DEFAULT_PROMPT_TEMPLATE = (
-      'The following is a conversation history between a user and an AI'
-      ' agent. Please summarize the conversation, focusing on key'
-      ' information and decisions made, as well as any unresolved'
+      'The following is a conversation history between a user and an AI agent.'
+      ' It may or may not start from a compacted history. Please identify and'
+      ' reiterate the user request, summarize the context so far, focusing on'
+      ' key decisions made and information obtained, as well as any unresolved'
       ' questions or tasks. The summary should be concise and capture the'
-      ' essence of the interaction.\\n\\n{conversation_history}'
+      ' essence of the interaction.\n\n{conversation_history}'
   )
 
+  # Tool call args and responses can be large (e.g. search results). Cap how
+  # much of each is rendered so compaction does not inflate the very context
+  # it exists to shrink.
+  _MAX_TOOL_CONTENT_CHARS = 2000
+
   def __init__(
       self,
       llm: BaseLlm,
@@ -71,14 +77,42 @@ def __init__(
     self._prompt_template = prompt_template or self._DEFAULT_PROMPT_TEMPLATE
 
   def _format_events_for_prompt(self, events: list[Event]) -> str:
-    """Formats a list of events into a string for the LLM prompt."""
+    """Formats events into prompt text, including thoughts and tool calls.
+
+    Thoughts carry the agent's analysis of tool responses, and tool calls and
+    responses carry the evidence retrieved so far, so all three are included.
+    Thoughts emitted by a compaction event are skipped so a prior summary's
+    reasoning does not leak into the next summary.
+    """
     formatted_history = []
     for event in events:
-      if event.content and event.content.parts:
-        for part in event.content.parts:
-          if part.text:
-            formatted_history.append(f'{event.author}: {part.text}')
-    return '\\n'.join(formatted_history)
+      if not (event.content and event.content.parts):
+        continue
+      is_compaction = bool(event.actions and event.actions.compaction)
+      for part in event.content.parts:
+        if part.thought and part.text:
+          if not is_compaction:
+            formatted_history.append(f'{event.author} (thought): {part.text}')
+        elif part.text:
+          formatted_history.append(f'{event.author}: {part.text}')
+        if part.function_call:
+          args = self._truncate(str(part.function_call.args))
+          formatted_history.append(
+              f'{event.author} called tool: {part.function_call.name}({args})'
+          )
+        if part.function_response:
+          response = self._truncate(str(part.function_response.response))
+          formatted_history.append(
+              f'Tool response from {part.function_response.name}: {response}'
+          )
+    return '\n'.join(formatted_history)
+
+  def _truncate(self, text: str) -> str:
+    """Caps `text` at the tool-content limit, marking dropped characters."""
+    limit = self._MAX_TOOL_CONTENT_CHARS
+    if len(text) <= limit:
+      return text
+    return f'{text[:limit]}... [truncated {len(text) - limit} chars]'
 
   async def maybe_summarize_events(
       self, *, events: list[Event]

tests/unittests/apps/test_llm_event_summarizer.py

@@ -54,7 +54,7 @@ async def test_maybe_compact_events_success(self):
         self._create_event(1.0, 'Hello', 'user'),
         self._create_event(2.0, 'Hi there!', 'model'),
     ]
-    expected_conversation_history = 'user: Hello\\nmodel: Hi there!'
+    expected_conversation_history = 'user: Hello\nmodel: Hi there!'
     expected_prompt = self.compactor._DEFAULT_PROMPT_TEMPLATE.format(
         conversation_history=expected_conversation_history
     )
@@ -162,7 +162,7 @@ def test_format_events_for_prompt(self):
                 parts=[
                     Part(
                         function_call=FunctionCall(
-                            id='call_1', name='tool', args={}
+                            id='call_1', name='tool', args={'q': 'x'}
                         )
                     )
                 ]
@@ -186,8 +186,80 @@ def test_format_events_for_prompt(self):
         ),
     ]
     expected_formatted_history = (
-        'user: User says...\\nmodel: Model replies...\\nuser: Another user'
-        ' input\\nmodel: More model text'
+        'user: User says...\nmodel: Model replies...\nuser: Another user'
+        ' input\nmodel: More model text\nmodel called tool:'
+        " tool({'q': 'x'})\nTool response from tool: {'result': 'done'}"
     )
     formatted_history = self.compactor._format_events_for_prompt(events)
     self.assertEqual(formatted_history, expected_formatted_history)
+
+  def test_format_events_for_prompt_includes_thoughts(self):
+    events = [
+        self._create_event(1.0, 'What is the weather?', 'user'),
+        Event(
+            timestamp=2.0,
+            author='model',
+            content=Content(
+                parts=[
+                    Part(text='Let me check the tool output.', thought=True),
+                    Part(text='It is sunny.'),
+                ]
+            ),
+        ),
+    ]
+    expected_formatted_history = (
+        'user: What is the weather?\nmodel (thought): Let me check the tool'
+        ' output.\nmodel: It is sunny.'
+    )
+    formatted_history = self.compactor._format_events_for_prompt(events)
+    self.assertEqual(formatted_history, expected_formatted_history)
+
+  def test_format_events_for_prompt_skips_compaction_event_thought(self):
+    events = [
+        Event(
+            timestamp=1.0,
+            author='model',
+            content=Content(
+                parts=[
+                    Part(text='Stale summarizer reasoning.', thought=True),
+                    Part(text='Prior summary.'),
+                ]
+            ),
+            actions=EventActions(
+                compaction=EventCompaction(
+                    start_timestamp=0.0,
+                    end_timestamp=1.0,
+                    compacted_content=Content(parts=[Part(text='Prior')]),
+                )
+            ),
+        ),
+        self._create_event(2.0, 'New user input', 'user'),
+    ]
+    expected_formatted_history = 'model: Prior summary.\nuser: New user input'
+    formatted_history = self.compactor._format_events_for_prompt(events)
+    self.assertEqual(formatted_history, expected_formatted_history)
+
+  def test_format_events_for_prompt_truncates_large_tool_response(self):
+    limit = self.compactor._MAX_TOOL_CONTENT_CHARS
+    large_value = 'x' * (limit + 500)
+    events = [
+        Event(
+            timestamp=1.0,
+            author='model',
+            content=Content(
+                parts=[
+                    Part(
+                        function_response=FunctionResponse(
+                            id='call_1',
+                            name='search',
+                            response={'data': large_value},
+                        )
+                    )
+                ]
+            ),
+        ),
+    ]
+    formatted_history = self.compactor._format_events_for_prompt(events)
+    self.assertIn('Tool response from search:', formatted_history)
+    self.assertIn('... [truncated', formatted_history)
+    self.assertLess(len(formatted_history), len(large_value))