Merge branch 'main' into fix/2652-agentevaluator-csv-export

Author: vaibhav-patel

src/google/adk/models/interactions_utils.py

@@ -72,6 +72,7 @@
 from google.genai.interactions import ThoughtStep
 from google.genai.interactions import ThoughtStepParam
 from google.genai.interactions import ToolParam
+from google.genai.interactions import UnknownStepDeltaData
 from google.genai.interactions import UserInputStepParam
 from google.genai.interactions import VideoContentParam
 from pydantic import BaseModel
@@ -779,6 +780,101 @@ def _handle_arguments_delta(
   return _partial_part_response(chunk_part, interaction_id)
 
 
+def _handle_unknown_delta(
+    delta: StepDeltaData, state: _StreamState, interaction_id: str | None
+) -> LlmResponse | None:
+  """Generic fallback: log the unhandled delta, emit nothing."""
+  if isinstance(delta, UnknownStepDeltaData):
+    # Forward-compat surprise: preserve the raw payload so it isn't lost.
+    logger.warning(
+        'Interactions streaming converter received unrecognized step delta;'
+        ' skipping (no event emitted). raw=%r',
+        delta.raw,
+    )
+  else:
+    # Known delta type we deliberately don't handle yet: keep log noise low.
+    logger.debug(
+        'Interactions streaming converter received unhandled step delta type'
+        ' %r; skipping (no event emitted).',
+        delta.type,
+    )
+  return None
+
+
+def _handle_thought_summary(
+    delta: StepDeltaData, state: _StreamState, interaction_id: str | None
+) -> LlmResponse | None:
+  content = delta.content
+  text = None
+  if content is not None and getattr(content, 'type', None) == 'text':
+    text = content.text
+  if not text:
+    return None
+  part = types.Part(text=text, thought=True)
+  state.parts.append(part)
+  return _partial_part_response(part, interaction_id)
+
+
+def _handle_thought_signature(
+    delta: StepDeltaData, state: _StreamState, interaction_id: str | None
+) -> LlmResponse | None:
+  signature = delta.signature
+  if not signature:
+    return None
+  for part in reversed(state.parts):
+    if part.thought:
+      part.thought_signature = base64.b64decode(signature)
+      break
+  return None
+
+
+def _handle_code_execution_call(
+    delta: StepDeltaData, state: _StreamState, interaction_id: str | None
+) -> LlmResponse | None:
+  args = delta.arguments
+  code = args.code if args else None
+  if not code:
+    return None
+  language = (
+      types.Language.PYTHON
+      if args.language and args.language.lower() == 'python'
+      else types.Language.LANGUAGE_UNSPECIFIED
+  )
+  part = types.Part(
+      executable_code=types.ExecutableCode(code=code, language=language)
+  )
+  state.parts.append(part)
+  return _partial_part_response(part, interaction_id)
+
+
+def _handle_code_execution_result(
+    delta: StepDeltaData, state: _StreamState, interaction_id: str | None
+) -> LlmResponse | None:
+  part = types.Part(
+      code_execution_result=types.CodeExecutionResult(
+          output=delta.result or '',
+          outcome=types.Outcome.OUTCOME_FAILED
+          if delta.is_error
+          else types.Outcome.OUTCOME_OK,
+      )
+  )
+  state.parts.append(part)
+  return _partial_part_response(part, interaction_id)
+
+
+def _handle_function_result(
+    delta: StepDeltaData, state: _StreamState, interaction_id: str | None
+) -> LlmResponse | None:
+  part = types.Part(
+      function_response=types.FunctionResponse(
+          id=delta.call_id or '',
+          response=_function_result_to_response(delta.result),
+      )
+  )
+  state.parts.append(part)
+  return _partial_part_response(part, interaction_id)
+
+
 def convert_interaction_event_to_llm_response(
     event: InteractionSSEEvent,
     state: _StreamState,
@@ -823,10 +919,22 @@ def convert_interaction_event_to_llm_response(
 
     if delta_type == 'text':
       return _handle_text(delta, state, interaction_id)
-    elif delta_type == 'image':
+    elif delta_type == 'thought_summary':
+      return _handle_thought_summary(delta, state, interaction_id)
+    elif delta_type == 'thought_signature':
+      return _handle_thought_signature(delta, state, interaction_id)
+    elif delta_type in ('image', 'audio', 'video', 'document'):
       return _handle_media(delta, state, interaction_id)
     elif delta_type == 'arguments_delta':
       return _handle_arguments_delta(delta, state, interaction_id)
+    elif delta_type == 'code_execution_call':
+      return _handle_code_execution_call(delta, state, interaction_id)
+    elif delta_type == 'code_execution_result':
+      return _handle_code_execution_result(delta, state, interaction_id)
+    elif delta_type == 'function_result':
+      return _handle_function_result(delta, state, interaction_id)
+    else:
+      return _handle_unknown_delta(delta, state, interaction_id)
 
   elif isinstance(event, StepStop):
     if state.parts and state.parts[-1].function_call:

tests/unittests/models/test_interactions_utils.py

@@ -21,6 +21,7 @@
 from datetime import datetime
 from datetime import timezone
 import json
+import logging
 from unittest.mock import MagicMock
 
 from google.adk.models import interactions_utils
@@ -1248,6 +1249,214 @@ def test_image_delta_with_data(self):
     assert result.content.parts[0].inline_data.data == b'image_bytes'
     assert len(state.parts) == 1
 
+  def test_thought_summary_delta(self):
+    """thought_summary delta becomes a thought part."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={
+            'type': 'thought_summary',
+            'content': {'type': 'text', 'text': 'Let me think...'},
+        },
+    )
+    state = interactions_utils._StreamState()
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, state, interaction_id='int_t'
+    )
+    assert result is not None
+    assert result.partial is True
+    part = result.content.parts[0]
+    assert part.text == 'Let me think...'
+    assert part.thought is True
+    assert len(state.parts) == 1
+
+  def test_thought_signature_delta_attaches_to_last_thought(self):
+    """thought_signature mutates the last thought part and emits no event."""
+    state = interactions_utils._StreamState()
+    interactions_utils.convert_interaction_event_to_llm_response(
+        StepDelta(
+            event_type='step.delta',
+            index=0,
+            delta={
+                'type': 'thought_summary',
+                'content': {'type': 'text', 'text': 'reasoning'},
+            },
+        ),
+        state,
+        interaction_id='int_ts',
+    )
+    sig_b64 = base64.b64encode(b'sig-bytes').decode('utf-8')
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        StepDelta(
+            event_type='step.delta',
+            index=0,
+            delta={'type': 'thought_signature', 'signature': sig_b64},
+        ),
+        state,
+        interaction_id='int_ts',
+    )
+    assert result is None
+    assert state.parts[-1].thought_signature == b'sig-bytes'
+
+  def test_audio_delta_with_data(self):
+    """audio delta becomes an inline_data part via the shared media handler."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={
+            'type': 'audio',
+            'data': base64.b64encode(b'audio_bytes').decode('utf-8'),
+            'mime_type': 'audio/wav',
+        },
+    )
+    state = interactions_utils._StreamState()
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, state, interaction_id='int_a'
+    )
+    assert result is not None
+    assert result.partial is True
+    assert result.content.parts[0].inline_data.data == b'audio_bytes'
+    assert result.content.parts[0].inline_data.mime_type == 'audio/wav'
+    assert len(state.parts) == 1
+
+  def test_code_execution_call_delta(self):
+    """code_execution_call delta becomes an executable_code part."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={
+            'type': 'code_execution_call',
+            'arguments': {'code': 'print(1)', 'language': 'python'},
+        },
+    )
+    state = interactions_utils._StreamState()
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, state, interaction_id='int_c'
+    )
+    assert result is not None
+    part = result.content.parts[0]
+    assert part.executable_code.code == 'print(1)'
+    assert part.executable_code.language == types.Language.PYTHON
+    assert len(state.parts) == 1
+
+  def test_code_execution_result_delta(self):
+    """code_execution_result delta becomes a code_execution_result part."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={
+            'type': 'code_execution_result',
+            'result': '1\n',
+            'is_error': False,
+        },
+    )
+    state = interactions_utils._StreamState()
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, state, interaction_id='int_cr'
+    )
+    assert result is not None
+    part = result.content.parts[0]
+    assert part.code_execution_result.output == '1\n'
+    assert part.code_execution_result.outcome == types.Outcome.OUTCOME_OK
+    assert len(state.parts) == 1
+
+  def test_code_execution_result_error_delta(self):
+    """code_execution_result with is_error maps to OUTCOME_FAILED."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={
+            'type': 'code_execution_result',
+            'result': 'Traceback (most recent call last): ...',
+            'is_error': True,
+        },
+    )
+    state = interactions_utils._StreamState()
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, state, interaction_id='int_cr_err'
+    )
+    assert result is not None
+    part = result.content.parts[0]
+    assert (
+        part.code_execution_result.output
+        == 'Traceback (most recent call last): ...'
+    )
+    assert part.code_execution_result.outcome == types.Outcome.OUTCOME_FAILED
+    assert len(state.parts) == 1
+
+  def test_function_result_delta(self):
+    """function_result delta becomes a function_response part."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={
+            'type': 'function_result',
+            'call_id': 'call_9',
+            'result': {'temp': 72},
+        },
+    )
+    state = interactions_utils._StreamState()
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, state, interaction_id='int_fr'
+    )
+    assert result is not None
+    part = result.content.parts[0]
+    assert part.function_response.id == 'call_9'
+    assert part.function_response.response == {'temp': 72}
+    assert len(state.parts) == 1
+
+  def test_known_unhandled_delta_type_logs_debug_and_drops(self, caplog):
+    """A known but unhandled delta type logs at debug and emits no event."""
+    # 'url_context_call' is a recognized genai delta variant that ADK does not
+    # handle yet, so it must fall through to the debug branch (not a warning).
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={'type': 'url_context_call', 'arguments': {}},
+    )
+    state = interactions_utils._StreamState()
+    with caplog.at_level(logging.DEBUG, logger=interactions_utils.logger.name):
+      result = interactions_utils.convert_interaction_event_to_llm_response(
+          event, state, interaction_id='int_u'
+      )
+    assert result is None
+    assert not state.parts
+    debug_records = [
+        r
+        for r in caplog.records
+        if r.levelno == logging.DEBUG
+        and 'unhandled step delta type' in r.message
+    ]
+    assert len(debug_records) == 1
+    assert not [r for r in caplog.records if r.levelno >= logging.WARNING]
+
+  def test_unrecognized_delta_logs_raw_warning_and_drops(self, caplog):
+    """A truly-unrecognized delta logs a warning preserving its raw payload."""
+    event = StepDelta(
+        event_type='step.delta',
+        index=0,
+        delta={'type': 'totally_made_up_xyz', 'foo': 'bar'},
+    )
+    state = interactions_utils._StreamState()
+    with caplog.at_level(
+        logging.WARNING, logger=interactions_utils.logger.name
+    ):
+      result = interactions_utils.convert_interaction_event_to_llm_response(
+          event, state, interaction_id='int_u2'
+      )
+    assert result is None
+    assert not state.parts
+    warnings = [
+        r
+        for r in caplog.records
+        if r.levelno == logging.WARNING
+        and 'unrecognized step delta' in r.message
+    ]
+    assert len(warnings) == 1
+    assert 'foo' in warnings[0].message
+    # The full raw payload (not just delta.type='UNKNOWN') is preserved.
+    assert warnings[0].args == {'type': 'totally_made_up_xyz', 'foo': 'bar'}
+
   def test_unknown_event_type_returns_none(self):
     """Test that unknown event types return None."""
     event = MagicMock()