fix: adapt interactions conversion to google-genai 2.9 SDK changes

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

Author: GWeale

pyproject.toml

@@ -36,7 +36,7 @@ dependencies = [
   "click>=8.1.8,<9",
   "fastapi>=0.133,<1",
   "google-auth[pyopenssl]>=2.47",
-  "google-genai>=2.8,<3",
+  "google-genai>=2.9,<3",
   "graphviz>=0.20.2,<1",
   "httpx>=0.27,<1",
   "jsonschema>=4.23,<5",

src/google/adk/models/interactions_utils.py

@@ -31,9 +31,9 @@
 from __future__ import annotations
 
 import base64
-import binascii
 import json
 import logging
+from typing import Any
 from typing import AsyncGenerator
 from typing import TYPE_CHECKING
 
@@ -72,6 +72,7 @@
 from google.genai.interactions import ToolParam
 from google.genai.interactions import UserInputStepParam
 from google.genai.interactions import VideoContentParam
+from pydantic import BaseModel
 from typing_extensions import deprecated
 
 if TYPE_CHECKING:
@@ -108,18 +109,6 @@ def _extract_stream_interaction_id(
   return None
 
 
-def _decode_base64_string(signature: str | None) -> bytes | None:
-  """Decode a base64 encoded string."""
-  if not signature or not isinstance(signature, str):
-    return None
-
-  try:
-    return base64.b64decode(signature)
-  except binascii.Error as e:
-    logger.error('Failed to decode base64 string: %s', e)
-    return None
-
-
 def _encode_base64_string(data: bytes) -> str:
   """Encode bytes to a base64 string."""
   return base64.b64encode(data).decode('utf-8')
@@ -284,17 +273,12 @@ def _convert_part_to_interaction_content(
         TextContentParam(type='text', text=part.text), role
     )
   elif part.function_call is not None:
-    func_call_step = FunctionCallStepParam(
+    return FunctionCallStepParam(
         type='function_call',
         id=part.function_call.id or '',
         name=part.function_call.name or '',
         arguments=part.function_call.args or {},
     )
-    if part.thought_signature is not None:
-      func_call_step['signature'] = _encode_base64_string(
-          part.thought_signature
-      )
-    return func_call_step
   elif part.function_response is not None:
 
     # genai.types.FunctionResponse specifies that
@@ -511,6 +495,31 @@ def convert_tools_config_to_interactions_format(
   return interaction_tools
 
 
+def _function_result_to_response(
+    result: BaseModel | dict[str, Any] | list[Any] | str,
+) -> dict[str, Any]:
+  """Convert a FunctionResultStep result into a FunctionResponse dict.
+
+  The Interactions API types the result as a model, a list of content blocks,
+  or a plain string, but types.FunctionResponse.response requires a dict. A
+  dict is returned as-is; other non-dict shapes are wrapped under a 'result'
+  key.
+  """
+  if isinstance(result, dict):
+    return result
+  if isinstance(result, BaseModel):
+    return result.model_dump()
+  if isinstance(result, list):
+    items: list[Any] = []
+    for item in result:
+      if isinstance(item, BaseModel):
+        items.append(item.model_dump())
+      else:
+        items.append(item)
+    return {'result': items}
+  return {'result': result}
+
+
 def _convert_interaction_step_to_parts(step: Step) -> list[types.Part]:
   """Convert an interaction output content to a list of types.Part.
 
@@ -554,23 +563,21 @@ def _convert_interaction_step_to_parts(step: Step) -> list[types.Part]:
         step.name,
         step.id,
     )
-    thought_signature = _decode_base64_string(step.signature)
     return [
         types.Part(
             function_call=types.FunctionCall(
                 id=step.id,
                 name=step.name,
                 args=step.arguments or {},
             ),
-            thought_signature=thought_signature,
         )
     ]
   elif isinstance(step, FunctionResultStep):
     return [
         types.Part(
             function_response=types.FunctionResponse(
                 id=step.call_id or '',
-                response=step.result,
+                response=_function_result_to_response(step.result),
             )
         )
     ]
@@ -624,13 +631,15 @@ def convert_interaction_to_llm_response(
   """
   from .llm_response import LlmResponse
 
-  # Check for errors
+  # Check for errors. Lifecycle SSE events carry a partial interaction
+  # (InteractionSseEventInteraction) that has no 'error' attribute.
   if interaction.status == 'failed':
     error_msg = 'Unknown error'
     error_code = 'UNKNOWN_ERROR'
-    if interaction.error:
-      error_msg = interaction.error.message or error_msg
-      error_code = interaction.error.code or error_code
+    error = getattr(interaction, 'error', None)
+    if error:
+      error_msg = error.message or error_msg
+      error_code = error.code or error_code
     return LlmResponse(
         error_code=error_code,
         error_message=error_msg,
@@ -703,14 +712,12 @@ def convert_interaction_event_to_llm_response(
     # 2. StepDelta (multiple): Streams arguments as raw JSON strings via arguments.
     # 3. StepStop: Signals the end of the step, where arguments are finalized and parsed.
     if isinstance(event.step, FunctionCallStep):
-      thought_signature = _decode_base64_string(event.step.signature)
-
       fc = types.FunctionCall(
           id=event.step.id,
           name=event.step.name,
           partial_args=[],
       )
-      part = types.Part(function_call=fc, thought_signature=thought_signature)
+      part = types.Part(function_call=fc)
       aggregated_parts.append(part)
 
       return LlmResponse(

tests/unittests/models/test_interactions_utils.py

@@ -33,6 +33,7 @@
 from google.genai.interactions import Interaction
 from google.genai.interactions import InteractionCompletedEvent
 from google.genai.interactions import InteractionCreatedEvent
+from google.genai.interactions import InteractionSseEventInteraction
 from google.genai.interactions import ModelOutputStep
 from google.genai.interactions import StepDelta
 from google.genai.interactions import StepStart
@@ -110,9 +111,9 @@ def fc_step() -> FunctionCallStep:
 
 def _build_lifecycle_streamed_events(fc_step: FunctionCallStep) -> list[object]:
   """Build streamed events with lifecycle updates carrying the ID."""
-  now = datetime.now(timezone.utc)
+  now = datetime.now(timezone.utc).isoformat()
 
-  interaction = Interaction(
+  interaction = InteractionSseEventInteraction(
       id='interaction_123',
       created=now,
       updated=now,
@@ -134,9 +135,9 @@ def _build_lifecycle_streamed_events(fc_step: FunctionCallStep) -> list[object]:
 
 def _build_complete_streamed_events(fc_step: FunctionCallStep) -> list[object]:
   """Build streamed events with the ID on an interaction.complete event."""
-  now = datetime.now(timezone.utc)
+  now = datetime.now(timezone.utc).isoformat()
 
-  interaction = Interaction(
+  interaction = InteractionSseEventInteraction(
       id='interaction_complete_123',
       created=now,
       updated=now,
@@ -154,7 +155,7 @@ def _build_complete_streamed_events(fc_step: FunctionCallStep) -> list[object]:
 
 def _build_legacy_streamed_events(fc_step: FunctionCallStep) -> list[object]:
   """Build streamed events with the ID on the legacy interaction event."""
-  now = datetime.now(timezone.utc)
+  now = datetime.now(timezone.utc).isoformat()
 
   interaction = Interaction(
       id='interaction_legacy_123',
@@ -246,8 +247,8 @@ def test_function_call_part_no_id(self):
     assert result['id'] == ''
     assert result['name'] == 'get_weather'
 
-  def test_function_call_part_with_thought_signature(self):
-    """Test converting a function call Part with thought_signature."""
+  def test_function_call_part_thought_signature_dropped(self):
+    """Thought signatures are not sent on interactions function call steps."""
     part = types.Part(
         function_call=types.FunctionCall(
             id='call_456',
@@ -257,14 +258,13 @@ def test_function_call_part_with_thought_signature(self):
         thought_signature=b'test_signature_bytes',
     )
     result = interactions_utils._convert_part_to_interaction_content(part)
-    assert result['type'] == 'function_call'
-    assert result['id'] == 'call_456'
-    assert result['name'] == 'my_tool'
-    assert result['arguments'] == {'doc': 'content'}
-    # signature should be base64 encoded
-    assert 'signature' in result
-
-    assert base64.b64decode(result['signature']) == b'test_signature_bytes'
+    assert result == {
+        'type': 'function_call',
+        'id': 'call_456',
+        'name': 'my_tool',
+        'arguments': {'doc': 'content'},
+    }
+    assert 'signature' not in result
 
   def test_function_call_part_without_thought_signature(self):
     """Test converting a function call Part without thought_signature."""
@@ -765,23 +765,6 @@ def test_function_call_output(self):
     assert result.function_call.name == 'get_weather'
     assert result.function_call.args == {'city': 'London'}
 
-  def test_function_call_output_with_thought_signature(self):
-    """Test converting function call output with thought_signature."""
-    output = FunctionCallStep(
-        type='function_call',
-        id='call_sig_123',
-        name='gemini3_tool',
-        arguments={'content': 'hello'},
-        signature=base64.b64encode(b'gemini3_signature').decode('utf-8'),
-    )
-    result_list = interactions_utils._convert_interaction_step_to_parts(output)
-    result = result_list[0] if result_list else None
-    assert result.function_call.id == 'call_sig_123'
-    assert result.function_call.name == 'gemini3_tool'
-    assert result.function_call.args == {'content': 'hello'}
-    # thought_signature should be decoded back to bytes
-    assert result.thought_signature == b'gemini3_signature'
-
   def test_function_call_output_without_thought_signature(self):
     """Test converting function call output without thought_signature."""
     output = FunctionCallStep(
@@ -809,6 +792,41 @@ def test_function_result_output(self):
     assert result.function_response.id == 'call_123'
     assert result.function_response.response == {'weather': 'Sunny'}
 
+  def test_function_result_output_preserves_none_values(self):
+    """None values in a dict result must not be dropped."""
+    output = FunctionResultStep(
+        type='function_result',
+        call_id='call_none',
+        result={'data': None, 'ok': True},
+    )
+    result_list = interactions_utils._convert_interaction_step_to_parts(output)
+    result = result_list[0] if result_list else None
+    assert result.function_response.response == {'data': None, 'ok': True}
+
+  def test_function_result_output_string(self):
+    """A plain string result is wrapped under a 'result' key."""
+    output = FunctionResultStep(
+        type='function_result',
+        call_id='call_str',
+        result='plain text',
+    )
+    result_list = interactions_utils._convert_interaction_step_to_parts(output)
+    result = result_list[0] if result_list else None
+    assert result.function_response.response == {'result': 'plain text'}
+
+  def test_function_result_output_list(self):
+    """A list result of content blocks is wrapped under a 'result' key."""
+    output = FunctionResultStep(
+        type='function_result',
+        call_id='call_list',
+        result=[{'type': 'text', 'text': 'hi'}],
+    )
+    result_list = interactions_utils._convert_interaction_step_to_parts(output)
+    result = result_list[0] if result_list else None
+    wrapped = result.function_response.response['result']
+    assert wrapped[0]['type'] == 'text'
+    assert wrapped[0]['text'] == 'hi'
+
   def test_image_output_with_data(self):
     """Test converting image output with inline data."""
     output = ModelOutputStep(
@@ -909,8 +927,8 @@ def test_successful_text_response(self):
     interaction = Interaction(
         id='interaction_123',
         status='completed',
-        created=datetime.now(timezone.utc),
-        updated=datetime.now(timezone.utc),
+        created=datetime.now(timezone.utc).isoformat(),
+        updated=datetime.now(timezone.utc).isoformat(),
         steps=[
             ModelOutputStep(
                 type='model_output',
@@ -933,8 +951,8 @@ def test_failed_response(self):
     interaction = Interaction(
         id='interaction_123',
         status='failed',
-        created=datetime.now(timezone.utc),
-        updated=datetime.now(timezone.utc),
+        created=datetime.now(timezone.utc).isoformat(),
+        updated=datetime.now(timezone.utc).isoformat(),
         steps=[],
     )
     interaction.error = MagicMock(code='INVALID_REQUEST', message='Bad request')
@@ -950,8 +968,8 @@ def test_requires_action_response(self):
     interaction = Interaction(
         id='interaction_123',
         status='requires_action',
-        created=datetime.now(timezone.utc),
-        updated=datetime.now(timezone.utc),
+        created=datetime.now(timezone.utc).isoformat(),
+        updated=datetime.now(timezone.utc).isoformat(),
         steps=[
             FunctionCallStep(
                 type='function_call',
@@ -1205,6 +1223,23 @@ def test_unknown_event_type_returns_none(self):
     assert result is None
     assert not aggregated_parts
 
+  def test_completed_event_failed_partial_interaction(self):
+    """A failed lifecycle event with a partial interaction does not crash."""
+    event = InteractionCompletedEvent(
+        event_type='interaction.completed',
+        interaction=InteractionSseEventInteraction(
+            id='int_failed',
+            status='failed',
+            steps=[],
+        ),
+    )
+    result = interactions_utils.convert_interaction_event_to_llm_response(
+        event, aggregated_parts=[], interaction_id='int_failed'
+    )
+    assert result is not None
+    assert result.error_code == 'UNKNOWN_ERROR'
+    assert result.interaction_id == 'int_failed'
+
   def test_function_call_streaming_flow(self):
     """Test the complete streaming flow for function calls (Start, Delta, Stop)."""
     # 1. StepStart