fix(deps): update dependency google-genai to v2 (#2464)

* fix(deps): update dependency google-genai to v2

* fix(llm): update google interactions translator

* fix(llm): require google genai v2

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Kevin Messiaen <114553769+kevinmessiaen@users.noreply.github.com>
Co-authored-by: Henrique Chaves <44180294+henchaves@users.noreply.github.com>

Author: 3 people

AGENTS.md

@@ -33,6 +33,9 @@ giskard-oss — behavioral config for interactive coding assistants with a human
 – When given a bug report with clear scope: just fix it
 – No `# type: ignore`, no patched test assertions — fix the root cause
 
+### 7. Commit Hygiene
+– Use Conventional Commits for every commit message (for example, `fix(llm): update google interactions translator`)
+
 ## Task Management
 1. Brainstorm → Spec → Plan — save to the repo's established planning docs, preferably `docs/specs/` and `docs/plans/`
 2. Verify Plan — check in before starting

libs/giskard-llm/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
 
 [project.optional-dependencies]
 openai = ["openai>=1.30,<3"]
-google = ["google-genai>=1.0,<2"]
+google = ["google-genai>=2.0,<3"]
 anthropic = ["anthropic>=0.40,<1"]
 azure = ["giskard-llm[openai]"]  # alias: azure/ and azure_ai/ use the openai SDK
 all = ["giskard-llm[openai,google,anthropic]"]

libs/giskard-llm/src/giskard/llm/translators/google_response.py

@@ -25,9 +25,11 @@
     from google.genai._interactions.types import (
         GenerationConfigParam,
         Interaction,
+        ModelOutputStepParam,
+        StepParam,
         TextContentParam,
         ToolParam,
-        TurnParam,
+        UserInputStepParam,
         interaction_create_params,
     )
     from httpx import Timeout as httpxTimeout
@@ -51,8 +53,6 @@ class InteractionCreateParams(TypedDict, total=False):
 KNOWN_RESPONSE_PARAMS = frozenset({"temperature", "timeout", "response_format"})
 
 
-_ROLE_MAP = {"user": "user", "assistant": "model"}
-
 logger = logging.getLogger(__name__)
 
 
@@ -70,6 +70,15 @@ def _text_content(text: str) -> "TextContentParam":
     return {"type": "text", "text": text}
 
 
+def _message_step(
+    role: Literal["user", "assistant"],
+    content: Iterable["TextContentParam"],
+) -> "UserInputStepParam | ModelOutputStepParam":
+    if role == "user":
+        return {"content": content, "type": "user_input"}
+    return {"content": content, "type": "model_output"}
+
+
 @ResponseInputText.register_serializer(_PROVIDER)
 def serialize_input_text(
     model: ResponseInputText, _info: SerializationInfo
@@ -94,75 +103,59 @@ def serialize_output_refusal(
 @ResponseEasyInputMessage.register_serializer(_PROVIDER)
 def serialize_easy_input_message(
     model: ResponseEasyInputMessage, info: SerializationInfo
-) -> "TurnParam | None":
+) -> "StepParam | None":
     if model.role == "developer" or model.role == "system":
         return None
 
     if isinstance(model.content, str):
-        return {
-            "content": [_text_content(model.content)],
-            "role": _ROLE_MAP[model.role],
-        }
+        return _message_step(model.role, [_text_content(model.content)])
 
     content = [
         cast("TextContentParam", cast(object, item.model_dump(context=info.context)))
         for item in model.content
     ]
-    return {"content": content, "role": _ROLE_MAP[model.role]}
+    return _message_step(model.role, content)
 
 
 @ResponseOutputMessage.register_serializer(_PROVIDER)
 def serialize_output_message(
     model: ResponseOutputMessage, info: SerializationInfo
-) -> "TurnParam":
+) -> "StepParam":
     if isinstance(model.content, str):
-        return {
-            "content": [_text_content(model.content)],
-            "role": _ROLE_MAP[model.role],
-        }
+        return _message_step(model.role, [_text_content(model.content)])
 
     content = [
         cast("TextContentParam", cast(object, item.model_dump(context=info.context)))
         for item in model.content
     ]
-    return {"content": content, "role": _ROLE_MAP[model.role]}
+    return _message_step(model.role, content)
 
 
 @ResponseFunctionToolCall.register_serializer(_PROVIDER)
 def serialize_output_function_call(
     model: ResponseFunctionToolCall, _info: SerializationInfo
-) -> "TurnParam":
+) -> "StepParam":
     return {
-        "content": [
-            {
-                "type": "function_call",
-                "id": model.call_id,
-                "name": model.name,
-                "arguments": deserialize_arguments(model.arguments),
-            }
-        ],
-        "role": "model",
+        "type": "function_call",
+        "id": model.call_id,
+        "name": model.name,
+        "arguments": deserialize_arguments(model.arguments),
     }
 
 
 @ResponseFunctionCallOutput.register_serializer(_PROVIDER)
 def serialize_output_function_call_output(
     model: ResponseFunctionCallOutput, _info: SerializationInfo
-) -> "TurnParam":
+) -> "StepParam":
     if model.name is None:
         # We cannot compute name from call_id alone since function calls are not guaranteed to be in the input.
         raise ValueError("name is required for function calls")
 
     return {
-        "content": [
-            {
-                "type": "function_result",
-                "call_id": model.call_id,
-                "name": model.name,
-                "result": model.output,
-            }
-        ],
-        "role": "user",
+        "type": "function_result",
+        "call_id": model.call_id,
+        "name": model.name,
+        "result": model.output,
     }
 
 
@@ -279,13 +272,16 @@ def to_google(
     @staticmethod
     def from_google(raw: "Interaction", model: str) -> ResponseResult:
         outputs: list[ResponseOutputItem] = []
-        for item in raw.outputs or []:
-            if item.type == "text":
-                outputs.append(
-                    ResponseOutputMessage(
-                        content=[ResponseOutputText(text=item.text)], role="assistant"
-                    )
-                )
+        for item in raw.steps or []:
+            if item.type == "model_output":
+                for content in item.content or []:
+                    if content.type == "text":
+                        outputs.append(
+                            ResponseOutputMessage(
+                                content=[ResponseOutputText(text=content.text)],
+                                role="assistant",
+                            )
+                        )
             elif item.type == "function_call":
                 outputs.append(
                     ResponseFunctionToolCall(

libs/giskard-llm/tests/test_providers.py

@@ -146,16 +146,21 @@ def _make_openai_response_api_response(
 
 def _make_google_interaction_response(
     id: str = "int_001",
-    output_items: list[Any] | None = None,
+    steps: list[Any] | None = None,
     input_tokens: int = 8,
     output_tokens: int = 4,
 ):
     """Mock the Gemini Interactions API shape."""
-    if output_items is None:
-        output_items = [SimpleNamespace(type="text", text="Bonjour")]
+    if steps is None:
+        steps = [
+            SimpleNamespace(
+                type="model_output",
+                content=[SimpleNamespace(type="text", text="Bonjour")],
+            )
+        ]
     return SimpleNamespace(
         id=id,
-        outputs=output_items,
+        steps=steps,
         usage=SimpleNamespace(
             total_input_tokens=input_tokens,
             total_output_tokens=output_tokens,
@@ -544,7 +549,7 @@ async def test_google_respond_function_call(mock_errors):
         arguments={"city": "Tokyo"},
     )
     provider._client.aio.interactions.create = AsyncMock(
-        return_value=_make_google_interaction_response(output_items=[fc_item])
+        return_value=_make_google_interaction_response(steps=[fc_item])
     )
 
     resp = await provider.respond("gemini-2.0-flash", "Weather?")

libs/giskard-llm/tests/translators/test_google_response.py

@@ -2,14 +2,15 @@
 
 Request shape mirrors :meth:`giskard.llm.translators.google_response.GoogleResponseTranslator.to_google`.
 Each :class:`~giskard.llm.types.ResponseEasyInputMessage` and message item serializes to one
-``TurnParam`` (``content`` + ``role``); :class:`~giskard.llm.types.ResponseFunctionToolCall`
-matches assistant replay as a model turn whose ``content`` contains ``function_call`` (``id``, not top-level ``call_id``);
-:class:`~giskard.llm.types.ResponseFunctionCallOutput` becomes a **user** turn whose ``content`` contains ``function_result``.
+``StepParam`` (``content`` + ``type``); :class:`~giskard.llm.types.ResponseFunctionToolCall`
+matches assistant replay as a ``function_call`` step (``id``, not ``call_id``);
+:class:`~giskard.llm.types.ResponseFunctionCallOutput` becomes a ``function_result`` step.
 ``None`` from system/developer turns is dropped.
 
-**Role mapping** (Gemini Interactions ``TurnParam.role``): ``user`` stays ``user``;
-``assistant`` becomes ``model`` (same for :class:`~giskard.llm.types.ResponseOutputMessage`).
-:class:`~giskard.llm.types.ResponseOutputFunctionCall` is always ``model``.
+**Step mapping** (Gemini Interactions ``StepParam.type``): ``user`` becomes
+``user_input``; ``assistant`` becomes ``model_output`` (same for
+:class:`~giskard.llm.types.ResponseOutputMessage`).
+:class:`~giskard.llm.types.ResponseOutputFunctionCall` is ``function_call``.
 System and developer text is not emitted as turns: it is merged into ``system_instruction``.
 
 For **return** mapping -> :class:`~giskard.llm.types.ResponseResult`, see ``test_google_response_return.py``.
@@ -93,42 +94,34 @@ def _text_part(text: str) -> dict[str, str]:
     return {**_TEXT, "text": text}
 
 
-def _msg_turn(role: Literal["user", "model"], text: str) -> dict[str, object]:
-    """One ``ResponseEasyInputMessage`` serializes to a single Interactions turn dict."""
-    return {"content": [_text_part(text)], "role": role}
+def _msg_step(
+    step_type: Literal["user_input", "model_output"], text: str
+) -> dict[str, object]:
+    """One ``ResponseEasyInputMessage`` serializes to a single Interactions step dict."""
+    return {"content": [_text_part(text)], "type": step_type}
 
 
 def _model_function_call_turn(
     call_id: str, name: str, arguments: dict[str, object]
 ) -> dict[str, object]:
     """Input ``ResponseFunctionToolCall`` matches assistant replay shape (Interactions API)."""
     return {
-        "content": [
-            {
-                "type": "function_call",
-                "id": call_id,
-                "name": name,
-                "arguments": arguments,
-            }
-        ],
-        "role": "model",
+        "type": "function_call",
+        "id": call_id,
+        "name": name,
+        "arguments": arguments,
     }
 
 
 def _user_function_result_turn(
     call_id: str, name: str, result: str
 ) -> dict[str, object]:
-    """``ResponseFunctionCallOutput`` → user turn with ``function_result`` content (Gemini API)."""
+    """``ResponseFunctionCallOutput`` -> ``function_result`` step (Gemini API)."""
     return {
-        "content": [
-            {
-                "type": "function_result",
-                "call_id": call_id,
-                "name": name,
-                "result": result,
-            }
-        ],
-        "role": "user",
+        "type": "function_result",
+        "call_id": call_id,
+        "name": name,
+        "result": result,
     }
 
 
@@ -146,7 +139,7 @@ def test_message_instruction_then_user(
     ]
     payload = GoogleResponseTranslator.to_google(_MODEL, items)
 
-    assert payload["input"] == [_msg_turn("user", "Hello.")]
+    assert payload["input"] == [_msg_step("user_input", "Hello.")]
     assert payload.get("system_instruction") == "You are helpful."
     validate_google_interaction_params(payload)
 
@@ -160,7 +153,7 @@ def test_message_system_then_developer_then_user():
     ]
     payload = GoogleResponseTranslator.to_google(_MODEL, items)
 
-    assert payload["input"] == [_msg_turn("user", "Hello.")]
+    assert payload["input"] == [_msg_step("user_input", "Hello.")]
     assert payload.get("system_instruction") == "You are helpful.\nApp version 2.0"
     validate_google_interaction_params(payload)
 
@@ -188,7 +181,7 @@ def test_message_two_instructions_then_user(
         ]
     payload = GoogleResponseTranslator.to_google(_MODEL, items)
 
-    assert payload["input"] == [_msg_turn("user", "Hello.")]
+    assert payload["input"] == [_msg_step("user_input", "Hello.")]
     assert (
         payload.get("system_instruction")
         == "First system instruction.\nSecond system instruction."
@@ -206,9 +199,9 @@ def test_message_user_assistant_user():
     payload = GoogleResponseTranslator.to_google(_MODEL, items)
 
     assert payload["input"] == [
-        _msg_turn("user", "First user."),
-        _msg_turn("model", "Assistant reply."),
-        _msg_turn("user", "Second user."),
+        _msg_step("user_input", "First user."),
+        _msg_step("model_output", "Assistant reply."),
+        _msg_step("user_input", "Second user."),
     ]
     assert "system_instruction" not in payload
     validate_google_interaction_params(payload)
@@ -223,7 +216,7 @@ def test_user_tool_call_and_result_with_tools():
         {"type": "function", **WEATHER_TOOL.function.model_dump()},
     ]
     assert payload.get("input") == [
-        _msg_turn("user", "What's the weather in Paris?"),
+        _msg_step("user_input", "What's the weather in Paris?"),
         _model_function_call_turn(TOOL_CALL_ID, "get_weather", {"city": "Paris"}),
         _user_function_result_turn(TOOL_CALL_ID, "get_weather", TOOL_RESULT_CONTENT),
     ]
@@ -240,7 +233,7 @@ def test_user_two_parallel_tool_calls_and_results_with_tools():
         {"type": "function", **GET_TIME_TOOL.function.model_dump()},
     ]
     assert payload.get("input") == [
-        _msg_turn("user", PARALLEL_USER_PROMPT),
+        _msg_step("user_input", PARALLEL_USER_PROMPT),
         _model_function_call_turn(
             TOOL_CALL_ID_WEATHER_PARALLEL,
             "get_weather",
@@ -275,8 +268,8 @@ def test_user_assistant_text_two_parallel_tool_calls_and_results_with_tools():
         {"type": "function", **GET_TIME_TOOL.function.model_dump()},
     ]
     assert payload.get("input") == [
-        _msg_turn("user", PARALLEL_USER_PROMPT),
-        _msg_turn("model", ASSISTANT_TEXT_WITH_PARALLEL_TOOLS),
+        _msg_step("user_input", PARALLEL_USER_PROMPT),
+        _msg_step("model_output", ASSISTANT_TEXT_WITH_PARALLEL_TOOLS),
         _model_function_call_turn(
             TOOL_CALL_ID_WEATHER_PARALLEL,
             "get_weather",
@@ -319,7 +312,7 @@ def test_assistant_message_mixed_output_text_and_refusal_maps_to_text_parts():
                 {"type": "text", "text": "Partial."},
                 {"type": "text", "text": "Stopped."},
             ],
-            "role": "model",
+            "type": "model_output",
         }
     ]
     validate_google_interaction_params(payload)