google-genai 1.57.0__py3-none-any.whl → 1.58.0__py3-none-any.whl

google/genai/_interactions/types/interaction.py

@@ -34,6 +34,7 @@ from .document_content import DocumentContent
 from .dynamic_agent_config import DynamicAgentConfig
 from .function_call_content import FunctionCallContent
 from .function_result_content import FunctionResultContent
+from .file_search_call_content import FileSearchCallContent
 from .url_context_call_content import URLContextCallContent
 from .deep_research_agent_config import DeepResearchAgentConfig
 from .file_search_result_content import FileSearchResultContent
@@ -71,6 +72,7 @@ Input: TypeAlias = Union[
     GoogleSearchResultContent,
     MCPServerToolCallContent,
     MCPServerToolResultContent,
+    FileSearchCallContent,
     FileSearchResultContent,
 ]
 

google/genai/_interactions/types/interaction_create_params.py

@@ -34,6 +34,7 @@ from .generation_config_param import GenerationConfigParam
 from .dynamic_agent_config_param import DynamicAgentConfigParam
 from .function_call_content_param import FunctionCallContentParam
 from .function_result_content_param import FunctionResultContentParam
+from .file_search_call_content_param import FileSearchCallContentParam
 from .url_context_call_content_param import URLContextCallContentParam
 from .deep_research_agent_config_param import DeepResearchAgentConfigParam
 from .file_search_result_content_param import FileSearchResultContentParam
@@ -117,6 +118,7 @@ Input: TypeAlias = Union[
     GoogleSearchResultContentParam,
     MCPServerToolCallContentParam,
     MCPServerToolResultContentParam,
+    FileSearchCallContentParam,
     FileSearchResultContentParam,
 ]
 

google/genai/_interactions/types/interaction_event.py

@@ -27,8 +27,7 @@ __all__ = ["InteractionEvent"]
 class InteractionEvent(BaseModel):
     event_id: Optional[str] = None
     """
-    The event_id token to be used to resume the interaction stream, from
-    this event.
+    The event_id token to be used to resume the interaction stream, from this event.
     """
 
     event_type: Optional[Literal["interaction.start", "interaction.complete"]] = None

google/genai/_interactions/types/interaction_sse_event.py

@@ -16,8 +16,9 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from typing import Union
-from typing_extensions import TypeAlias
+from typing_extensions import Annotated, TypeAlias
 
+from .._utils import PropertyInfo
 from .error_event import ErrorEvent
 from .content_stop import ContentStop
 from .content_delta import ContentDelta
@@ -27,6 +28,7 @@ from .interaction_status_update import InteractionStatusUpdate
 
 __all__ = ["InteractionSSEEvent"]
 
-InteractionSSEEvent: TypeAlias = Union[
-    InteractionEvent, InteractionStatusUpdate, ContentStart, ContentDelta, ContentStop, ErrorEvent
+InteractionSSEEvent: TypeAlias = Annotated[
+    Union[InteractionEvent, InteractionStatusUpdate, ContentStart, ContentDelta, ContentStop, ErrorEvent],
+    PropertyInfo(discriminator="event_type"),
 ]

google/genai/_interactions/types/interaction_status_update.py

@@ -26,8 +26,7 @@ __all__ = ["InteractionStatusUpdate"]
 class InteractionStatusUpdate(BaseModel):
     event_id: Optional[str] = None
     """
-    The event_id token to be used to resume the interaction stream, from
-    this event.
+    The event_id token to be used to resume the interaction stream, from this event.
     """
 
     event_type: Optional[Literal["interaction.status_update"]] = None

google/genai/_interactions/types/video_content.py

@@ -30,6 +30,7 @@ class VideoContent(BaseModel):
     type: Literal["video"]
 
     data: Optional[str] = None
+    """The video content."""
 
     mime_type: Optional[VideoMimeType] = None
     """The mime type of the video."""
@@ -38,3 +39,4 @@ class VideoContent(BaseModel):
     """The resolution of the media."""
 
     uri: Optional[str] = None
+    """The URI of the video."""

google/genai/_interactions/types/video_content_param.py

@@ -34,6 +34,7 @@ class VideoContentParam(TypedDict, total=False):
     type: Required[Literal["video"]]
 
     data: Annotated[Union[str, Base64FileInput], PropertyInfo(format="base64")]
+    """The video content."""
 
     mime_type: VideoMimeTypeParam
     """The mime type of the video."""
@@ -42,6 +43,7 @@ class VideoContentParam(TypedDict, total=False):
     """The resolution of the media."""
 
     uri: str
+    """The URI of the video."""
 
 
 set_pydantic_config(VideoContentParam, {"arbitrary_types_allowed": True})

google/genai/_live_converters.py

@@ -1151,6 +1151,59 @@ def _LiveSendRealtimeInputParameters_to_vertex(
   return to_object
 
 
+def _LiveServerMessage_from_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['setupComplete']) is not None:
+    setv(to_object, ['setup_complete'], getv(from_object, ['setupComplete']))
+
+  if getv(from_object, ['serverContent']) is not None:
+    setv(to_object, ['server_content'], getv(from_object, ['serverContent']))
+
+  if getv(from_object, ['toolCall']) is not None:
+    setv(to_object, ['tool_call'], getv(from_object, ['toolCall']))
+
+  if getv(from_object, ['toolCallCancellation']) is not None:
+    setv(
+        to_object,
+        ['tool_call_cancellation'],
+        getv(from_object, ['toolCallCancellation']),
+    )
+
+  if getv(from_object, ['usageMetadata']) is not None:
+    setv(to_object, ['usage_metadata'], getv(from_object, ['usageMetadata']))
+
+  if getv(from_object, ['goAway']) is not None:
+    setv(to_object, ['go_away'], getv(from_object, ['goAway']))
+
+  if getv(from_object, ['sessionResumptionUpdate']) is not None:
+    setv(
+        to_object,
+        ['session_resumption_update'],
+        getv(from_object, ['sessionResumptionUpdate']),
+    )
+
+  if getv(from_object, ['voiceActivityDetectionSignal']) is not None:
+    setv(
+        to_object,
+        ['voice_activity_detection_signal'],
+        getv(from_object, ['voiceActivityDetectionSignal']),
+    )
+
+  if getv(from_object, ['voiceActivity']) is not None:
+    setv(
+        to_object,
+        ['voice_activity'],
+        _VoiceActivity_from_mldev(
+            getv(from_object, ['voiceActivity']), to_object
+        ),
+    )
+
+  return to_object
+
+
 def _LiveServerMessage_from_vertex(
     from_object: Union[dict[str, Any], object],
     parent_object: Optional[dict[str, Any]] = None,
@@ -1198,6 +1251,15 @@ def _LiveServerMessage_from_vertex(
         getv(from_object, ['voiceActivityDetectionSignal']),
     )
 
+  if getv(from_object, ['voiceActivity']) is not None:
+    setv(
+        to_object,
+        ['voice_activity'],
+        _VoiceActivity_from_vertex(
+            getv(from_object, ['voiceActivity']), to_object
+        ),
+    )
+
   return to_object
 
 
@@ -1468,3 +1530,25 @@ def _UsageMetadata_from_vertex(
     setv(to_object, ['traffic_type'], getv(from_object, ['trafficType']))
 
   return to_object
+
+
+def _VoiceActivity_from_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['type']) is not None:
+    setv(to_object, ['voice_activity_type'], getv(from_object, ['type']))
+
+  return to_object
+
+
+def _VoiceActivity_from_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['type']) is not None:
+    setv(to_object, ['voice_activity_type'], getv(from_object, ['type']))
+
+  return to_object

google/genai/_transformers.py

@@ -285,29 +285,23 @@ def t_caches_model(
     return model
 
 
-def pil_to_blob(img: Any) -> types.Blob:
-  PngImagePlugin: Optional[builtin_types.ModuleType]
-  try:
-    import PIL.PngImagePlugin
-
-    PngImagePlugin = PIL.PngImagePlugin
-  except ImportError:
-    PngImagePlugin = None
-
-  bytesio = io.BytesIO()
+def pil_to_blob(image: Any) -> types.Blob:
+  image_format = 'PNG'
+  save_params: dict[str, Any] = dict()
   if (
-      PngImagePlugin is not None
-      and isinstance(img, PngImagePlugin.PngImageFile)
-      or img.mode == 'RGBA'
+      image.format == 'JPEG'
+      and getattr(image, 'filename', '')
+      and image.mode in ['1', 'L', 'RGB', 'RGBX', 'CMYK']
   ):
-    img.save(bytesio, format='PNG')
-    mime_type = 'image/png'
-  else:
-    img.save(bytesio, format='JPEG')
-    mime_type = 'image/jpeg'
-  bytesio.seek(0)
-  data = bytesio.read()
-  return types.Blob(mime_type=mime_type, data=data)
+    image_format = 'JPEG'
+    save_params.update(quality='keep')
+
+  image_io = io.BytesIO()
+  image.save(image_io, image_format, **save_params)
+  image_bytes = image_io.getvalue()
+  mime_type = f'image/{image_format.lower()}'
+
+  return types.Blob(data=image_bytes, mime_type=mime_type)
 
 
 def t_function_response(

google/genai/client.py

@@ -16,7 +16,7 @@
 import asyncio
 import os
 from types import TracebackType
-from typing import Optional, Union, cast
+from typing import Optional, Union
 
 import google.auth
 import pydantic
@@ -43,13 +43,65 @@ from ._api_client import has_aiohttp
 
 from . import _common
 
-from ._interactions import AsyncGeminiNextGenAPIClient, DEFAULT_MAX_RETRIES, DefaultAioHttpClient, GeminiNextGenAPIClient
-from ._interactions._models import FinalRequestOptions
-from ._interactions._types import Headers
-from ._interactions._utils import is_given
+from ._interactions import AsyncGeminiNextGenAPIClient, DEFAULT_MAX_RETRIES, GeminiNextGenAPIClient
+from . import _interactions
+
 from ._interactions.resources import AsyncInteractionsResource as AsyncNextGenInteractionsResource, InteractionsResource as NextGenInteractionsResource
 _interactions_experimental_warned = False
 
+class AsyncGeminiNextGenAPIClientAdapter(_interactions.AsyncGeminiNextGenAPIClientAdapter):
+  """Adapter for the Gemini NextGen API Client."""
+  def __init__(self, api_client: BaseApiClient):
+    self._api_client = api_client
+
+  def is_vertex_ai(self) -> bool:
+    return self._api_client.vertexai or False
+
+  def get_project(self) -> str | None:
+    return self._api_client.project
+
+  def get_location(self) -> str | None:
+    return self._api_client.location
+
+  async def async_get_auth_headers(self) -> dict[str, str]:
+    if self._api_client.api_key:
+      return {"x-goog-api-key": self._api_client.api_key}
+    access_token = await self._api_client._async_access_token()
+    headers = {
+      "Authorization": f"Bearer {access_token}",
+    }
+    if creds := self._api_client._credentials:
+      if creds.quota_project_id:
+        headers["x-goog-user-project"] = creds.quota_project_id
+    return headers
+
+
+class GeminiNextGenAPIClientAdapter(_interactions.GeminiNextGenAPIClientAdapter):
+  """Adapter for the Gemini NextGen API Client."""
+  def __init__(self, api_client: BaseApiClient):
+    self._api_client = api_client
+
+  def is_vertex_ai(self) -> bool:
+    return self._api_client.vertexai or False
+
+  def get_project(self) -> str | None:
+    return self._api_client.project
+
+  def get_location(self) -> str | None:
+    return self._api_client.location
+
+  def get_auth_headers(self) -> dict[str, str]:
+    if self._api_client.api_key:
+      return {"x-goog-api-key": self._api_client.api_key}
+    access_token = self._api_client._access_token()
+    headers = {
+      "Authorization": f"Bearer {access_token}",
+    }
+    if creds := self._api_client._credentials:
+      if creds.quota_project_id:
+        headers["x-goog-user-project"] = creds.quota_project_id
+    return headers
+
 
 class AsyncClient:
   """Client for making asynchronous (non-blocking) requests."""
@@ -122,6 +174,7 @@ class AsyncClient:
         # uSDk expects ms, nextgen uses a httpx Timeout -> expects seconds.
         timeout=http_opts.timeout / 1000 if http_opts.timeout else None,
         max_retries=max_retries,
+        client_adapter=AsyncGeminiNextGenAPIClientAdapter(self._api_client)
     )
 
     client = self._nextgen_client_instance
@@ -130,30 +183,6 @@ class AsyncClient:
       client._vertex_project = self._api_client.project
       client._vertex_location = self._api_client.location
 
-      async def prepare_options(options: FinalRequestOptions) -> FinalRequestOptions:
-        headers = {}
-        if is_given(options.headers):
-          headers = {**options.headers}
-
-        headers['Authorization'] = f'Bearer {await self._api_client._async_access_token()}'
-        if (
-            self._api_client._credentials
-            and self._api_client._credentials.quota_project_id
-        ):
-          headers['x-goog-user-project'] = (
-              self._api_client._credentials.quota_project_id
-          )
-        options.headers = headers
-
-        return options
-
-      if self._api_client.project or self._api_client.location:
-        client._prepare_options = prepare_options  # type: ignore[method-assign]
-
-    def validate_headers(headers: Headers, custom_headers: Headers) -> None:
-      return
-
-    client._validate_headers = validate_headers  # type: ignore[method-assign]
     return self._nextgen_client_instance
 
   @property
@@ -279,6 +308,7 @@ class DebugConfig(pydantic.BaseModel):
   )
 
 
+
 class Client:
   """Client for making synchronous requests.
 
@@ -492,39 +522,15 @@ class Client:
         # uSDk expects ms, nextgen uses a httpx Timeout -> expects seconds.
         timeout=http_opts.timeout / 1000 if http_opts.timeout else None,
         max_retries=max_retries,
+        client_adapter=GeminiNextGenAPIClientAdapter(self._api_client),
     )
 
     client = self._nextgen_client_instance
-    if self.vertexai:
+    if self._api_client.vertexai:
       client._is_vertex = True
       client._vertex_project = self._api_client.project
       client._vertex_location = self._api_client.location
 
-      def prepare_options(options: FinalRequestOptions) -> FinalRequestOptions:
-        headers = {}
-        if is_given(options.headers):
-          headers = {**options.headers}
-        options.headers = headers
-
-        headers['Authorization'] = f'Bearer {self._api_client._access_token()}'
-        if (
-            self._api_client._credentials
-            and self._api_client._credentials.quota_project_id
-        ):
-          headers['x-goog-user-project'] = (
-              self._api_client._credentials.quota_project_id
-          )
-
-        return options
-
-      if self._api_client.project or self._api_client.location:
-        client._prepare_options = prepare_options  # type: ignore[method-assign]
-
-    def validate_headers(headers: Headers, custom_headers: Headers) -> None:
-      return
-
-    client._validate_headers = validate_headers  # type: ignore[method-assign]
-
     return self._nextgen_client_instance
 
   @property

google/genai/live.py

@@ -1036,7 +1036,7 @@ class AsyncLive(_api_module.BaseModule):
           if requests is None:
             raise ValueError('The requests module is required to refresh google-auth credentials. Please install with `pip install google-auth[requests]`')
           auth_req = requests.Request()  # type: ignore
-          creds.refresh(auth_req)
+          creds.refresh(auth_req)  # type: ignore[no-untyped-call]
         bearer_token = creds.token
 
         original_headers = self._api_client._http_options.headers

google/genai/tests/client/test_custom_client.py

@@ -75,3 +75,30 @@ def test_constructor_with_httpx_clients():
   assert not mldev_client.models._api_client._use_aiohttp()
 
 
+# Aiohttp
+@requires_aiohttp
+@pytest.mark.asyncio
+@pytest.mark.skipif(
+    AIOHTTP_NOT_INSTALLED, reason='aiohttp is not installed, skipping test.'
+)
+async def test_constructor_with_aiohttp_clients():
+  api_client.has_aiohttp = True
+  mldev_http_options = {
+      'aiohttp_client': aiohttp.ClientSession(trust_env=False),
+  }
+  vertexai_http_options = {
+      'aiohttp_client': aiohttp.ClientSession(trust_env=False),
+  }
+  mldev_client = Client(
+      api_key='google_api_key', http_options=mldev_http_options
+  )
+  assert not mldev_client.models._api_client._aiohttp_session.trust_env
+
+  vertexai_client = Client(
+      vertexai=True,
+      project='fake_project_id',
+      location='fake-location',
+      http_options=vertexai_http_options,
+  )
+  assert not vertexai_client.models._api_client._aiohttp_session.trust_env
+

google/genai/tests/client/test_http_options.py

@@ -40,7 +40,7 @@ def test_patch_http_options_with_copies_all_fields():
 
   for key in http_options_keys:
     assert hasattr(patched, key)
-    if key not in ['httpx_client', 'httpx_async_client', 'aiohttp_client_session']:
+    if key not in ['httpx_client', 'httpx_async_client', 'aiohttp_client']:
       assert getattr(patched, key) is not None
   assert patched.base_url == 'https://fake-url.com/'
   assert patched.api_version == 'v1'

google/genai/tests/interactions/test_auth.py

@@ -214,7 +214,7 @@ def test_interactions_vertex_auth_refresh_on_retry():
             headers = mock_send.call_args_list[i][0][0].headers
             assert headers['authorization'] == f'Bearer {token_values[i]}'
 
-@pytest.mark.xfail(reason="extra_headers don't override default auth")
+
 def test_interactions_vertex_extra_headers_override():
     from ..._api_client import BaseApiClient
     from httpx import Client as HTTPClient
@@ -358,8 +358,6 @@ async def test_async_interactions_vertex_auth_header():
 @pytest.mark.asyncio
 async def test_async_interactions_vertex_key_no_auth_header():
   from ..._api_client import BaseApiClient
-  from ..._api_client import AsyncHttpxClient
-  creds = mock.Mock()
   client = Client(vertexai=True, api_key='test-api-key')
 
   with (
@@ -436,7 +434,6 @@ async def test_async_interactions_vertex_auth_refresh_on_retry():
             headers = mock_send.call_args_list[i][0][0].headers
             assert headers['authorization'] == f'Bearer {token_values[i]}'
 
-@pytest.mark.xfail(reason="extra_headers don't override default auth")
 @pytest.mark.asyncio
 async def test_async_interactions_vertex_extra_headers_override():
     from ..._api_client import BaseApiClient

google/genai/tests/interactions/test_integration.py

@@ -55,6 +55,7 @@ def test_client_timeout():
         http_client=mock.ANY,
         timeout=5.0,
         max_retries=mock.ANY,
+        client_adapter=mock.ANY,
     )
 
 
@@ -79,4 +80,5 @@ async def test_async_client_timeout():
         http_client=mock.ANY,
         timeout=5.0,
         max_retries=mock.ANY,
+        client_adapter=mock.ANY,
     )

google/genai/tests/transformers/test_blobs.py

@@ -26,14 +26,17 @@ from ... import types
 
 
 def test_blob_dict():
-  blob = t.t_blob({'data': bytes([0, 0, 0, 0, 0, 0]), 'mime_type': 'audio/pcm'}
-  )
+  blob = t.t_blob({
+      'data': bytes([0, 0, 0, 0, 0, 0]),
+      'mime_type': 'audio/pcm',
+  })
   assert blob.data == bytes([0, 0, 0, 0, 0, 0])
   assert blob.mime_type == 'audio/pcm'
 
 
 def test_blob():
-  blob = t.t_blob(types.Blob(data=bytes([0, 0, 0, 0, 0, 0]), mime_type='audio/pcm')
+  blob = t.t_blob(
+      types.Blob(data=bytes([0, 0, 0, 0, 0, 0]), mime_type='audio/pcm')
   )
   assert blob.data == bytes([0, 0, 0, 0, 0, 0])
   assert blob.mime_type == 'audio/pcm'
@@ -50,10 +53,12 @@ def test_image(image_jpeg):
   assert round_trip_image.mode == image_jpeg.mode
   assert round_trip_image.format == image_jpeg.format
 
+
 def test_not_image():
   blob = types.Blob(data=bytes([0, 0, 0, 0, 0, 0]), mime_type='audio/pcm')
   assert blob.as_image() is None
 
+
 def test_part_image(image_jpeg):
   part = t.t_part(image_jpeg)
   assert part.inline_data.data[6:10] == b'JFIF'
@@ -69,3 +74,11 @@ def test_part_image(image_jpeg):
 def test_part_not_image():
   part = t.t_part('hello world')
   assert part.as_image() is None
+
+
+def test_pil_to_blob_with_memory_pil_image():
+  img = PIL.Image.new('RGB', (1, 1), color='red')
+  blob = t.pil_to_blob(img)
+  assert blob.mime_type == 'image/png'
+  assert blob.data and len(blob.data) == 69
+  assert blob.data[0:4] == b'\x89PNG'

google/genai/types.py

@@ -108,6 +108,20 @@ else:
     HttpxClient = None
     HttpxAsyncClient = None
 
+_is_aiohttp_imported = False
+if typing.TYPE_CHECKING:
+  from aiohttp import ClientSession
+
+  _is_aiohttp_imported = True
+else:
+  ClientSession: typing.Type = Any
+  try:
+    from aiohttp import ClientSession
+
+    _is_aiohttp_imported = True
+  except ImportError:
+    ClientSession = None
+
 logger = logging.getLogger('google_genai.types')
 _from_json_schema_warning_logged = False
 _json_schema_warning_logged = False
@@ -869,6 +883,17 @@ class VadSignalType(_common.CaseInSensitiveEnum):
   """End of sentence signal."""
 
 
+class VoiceActivityType(_common.CaseInSensitiveEnum):
+  """The type of the voice activity signal."""
+
+  TYPE_UNSPECIFIED = 'TYPE_UNSPECIFIED'
+  """The default is VOICE_ACTIVITY_TYPE_UNSPECIFIED."""
+  ACTIVITY_START = 'ACTIVITY_START'
+  """Start of sentence signal."""
+  ACTIVITY_END = 'ACTIVITY_END'
+  """End of sentence signal."""
+
+
 class StartSensitivity(_common.CaseInSensitiveEnum):
   """Start of speech sensitivity."""
 
@@ -1925,6 +1950,10 @@ class HttpOptions(_common.BaseModel):
       default=None,
       description="""A custom httpx async client to be used for the request.""",
   )
+  aiohttp_client: Optional['ClientSession'] = Field(
+      default=None,
+      description="""A custom aiohttp client session to be used for the request.""",
+  )
 
 
 class HttpOptionsDict(TypedDict, total=False):
@@ -16347,6 +16376,24 @@ VoiceActivityDetectionSignalOrDict = Union[
 ]
 
 
+class VoiceActivity(_common.BaseModel):
+  """Voice activity signal."""
+
+  voice_activity_type: Optional[VoiceActivityType] = Field(
+      default=None, description="""The type of the voice activity signal."""
+  )
+
+
+class VoiceActivityDict(TypedDict, total=False):
+  """Voice activity signal."""
+
+  voice_activity_type: Optional[VoiceActivityType]
+  """The type of the voice activity signal."""
+
+
+VoiceActivityOrDict = Union[VoiceActivity, VoiceActivityDict]
+
+
 class LiveServerMessage(_common.BaseModel):
   """Response message for API call."""
 
@@ -16379,7 +16426,13 @@ class LiveServerMessage(_common.BaseModel):
       )
   )
   voice_activity_detection_signal: Optional[VoiceActivityDetectionSignal] = (
-      Field(default=None, description="""Voice activity detection signal.""")
+      Field(
+          default=None,
+          description="""Voice activity detection signal. Allowlisted only.""",
+      )
+  )
+  voice_activity: Optional[VoiceActivity] = Field(
+      default=None, description="""Voice activity signal."""
   )
 
   @property
@@ -16478,7 +16531,10 @@ class LiveServerMessageDict(TypedDict, total=False):
   """Update of the session resumption state."""
 
   voice_activity_detection_signal: Optional[VoiceActivityDetectionSignalDict]
-  """Voice activity detection signal."""
+  """Voice activity detection signal. Allowlisted only."""
+
+  voice_activity: Optional[VoiceActivityDict]
+  """Voice activity signal."""
 
 
 LiveServerMessageOrDict = Union[LiveServerMessage, LiveServerMessageDict]

google/genai/version.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 #
 
-__version__ = '1.57.0' # x-release-please-version
+__version__ = '1.58.0' # x-release-please-version