google-genai 1.8.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

google/genai/live.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Google LLC
+# Copyright 2025 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,14 +13,15 @@
 # limitations under the License.
 #
 
-"""Live client. The live module is experimental."""
+"""[Preview] Live API client."""
 
 import asyncio
 import base64
 import contextlib
 import json
 import logging
-from typing import Any, AsyncIterator, Dict, Optional, Sequence, Union, get_args
+from typing import Any, AsyncIterator, Dict, Optional, Sequence, Union, cast, get_args
+import warnings
 
 import google.auth
 import pydantic
@@ -30,7 +31,6 @@ from . import _api_module
 from . import _common
 from . import _transformers as t
 from . import client
-from . import errors
 from . import types
 from ._api_client import BaseApiClient
 from ._common import experimental_warning
@@ -65,8 +65,68 @@ _FUNCTION_RESPONSE_REQUIRES_ID = (
 )
 
 
+def _ClientContent_to_mldev(
+    api_client: BaseApiClient,
+    from_object: types.LiveClientContent,
+) -> dict:
+  client_content = from_object.model_dump(exclude_none=True, mode='json')
+  if 'turns' in client_content:
+    client_content['turns'] = [
+        _Content_to_mldev(api_client=api_client, from_object=item)
+        for item in client_content['turns']
+    ]
+  return client_content
+
+
+def _ClientContent_to_vertex(
+    api_client: BaseApiClient,
+    from_object: types.LiveClientContent,
+) -> dict:
+  client_content = from_object.model_dump(exclude_none=True, mode='json')
+  if 'turns' in client_content:
+    client_content['turns'] = [
+        _Content_to_vertex(api_client=api_client, from_object=item)
+        for item in client_content['turns']
+    ]
+  return client_content
+
+
+def _ToolResponse_to_mldev(
+    api_client: BaseApiClient,
+    from_object: types.LiveClientToolResponse,
+) -> dict:
+  tool_response = from_object.model_dump(exclude_none=True, mode='json')
+  for response in tool_response.get('function_responses', []):
+    if response.get('id') is None:
+      raise ValueError(_FUNCTION_RESPONSE_REQUIRES_ID)
+  return tool_response
+
+
+def _ToolResponse_to_vertex(
+    api_client: BaseApiClient,
+    from_object: types.LiveClientToolResponse,
+) -> dict:
+  tool_response = from_object.model_dump(exclude_none=True, mode='json')
+  return tool_response
+
+def _AudioTranscriptionConfig_to_mldev(
+    api_client: BaseApiClient,
+    from_object: types.AudioTranscriptionConfig,
+) -> dict:
+  audio_transcription: dict[str, Any] = {}
+  return audio_transcription
+
+
+def _AudioTranscriptionConfig_to_vertex(
+    api_client: BaseApiClient,
+    from_object: types.AudioTranscriptionConfig,
+) -> dict:
+  audio_transcription: dict[str, Any] = {}
+  return audio_transcription
+
+
 class AsyncSession:
-  """AsyncSession. The live module is experimental."""
+  """[Preview] AsyncSession."""
 
   def __init__(
       self, api_client: client.BaseApiClient, websocket: ClientConnection
@@ -90,7 +150,12 @@ class AsyncSession:
       ] = None,
       end_of_turn: Optional[bool] = False,
   ):
-    """Send input to the model.
+    """[Deprecated] Send input to the model.
+
+    > **Warning**: This method is deprecated and will be removed in a future
+    version (not before Q3 2025). Please use one of the more specific methods:
+    `send_client_content`, `send_realtime_input`, or `send_tool_response`
+    instead.
 
     The method will send the input request to the server.
 
@@ -109,9 +174,219 @@ class AsyncSession:
         async for message in session.receive():
           print(message)
     """
+    warnings.warn(
+        'The `session.send` method is deprecated and will be removed in a '
+        'future version (not before Q3 2025).\n'
+        'Please use one of the more specific methods: `send_client_content`, '
+        '`send_realtime_input`, or `send_tool_response` instead.',
+        DeprecationWarning,
+        stacklevel=2,
+    )
     client_message = self._parse_client_message(input, end_of_turn)
     await self._ws.send(json.dumps(client_message))
 
+  async def send_client_content(
+      self,
+      *,
+      turns: Optional[
+          Union[
+              types.Content,
+              types.ContentDict,
+              list[Union[types.Content, types.ContentDict]]
+          ]
+      ] = None,
+      turn_complete: bool = True,
+  ):
+    """Send non-realtime, turn based content to the model.
+
+    There are two ways to send messages to the live API:
+    `send_client_content` and `send_realtime_input`.
+
+    `send_client_content` messages are added to the model context **in order**.
+    Having a conversation using `send_client_content` messages is roughly
+    equivalent to using the `Chat.send_message_stream` method, except that the
+    state of the `chat` history is stored on the API server.
+
+    Because of `send_client_content`'s order guarantee, the model cannot
+    respond as quickly to `send_client_content` messages as to
+    `send_realtime_input` messages. This makes the biggest difference when
+    sending objects that have significant preprocessing time (typically images).
+
+    The `send_client_content` message sends a list of `Content` objects,
+    which has more options than the `media:Blob` sent by `send_realtime_input`.
+
+    The main use-cases for `send_client_content` over `send_realtime_input` are:
+
+    - Prefilling a conversation context (including sending anything that can't
+      be represented as a realtime message), before starting a realtime
+      conversation.
+    - Conducting a non-realtime conversation, similar to `client.chat`, using
+      the live api.
+
+    Caution: Interleaving `send_client_content` and `send_realtime_input`
+      in the same conversation is not recommended and can lead to unexpected
+      results.
+
+    Args:
+      turns: A `Content` object or list of `Content` objects (or equivalent
+        dicts).
+      turn_complete: if true (the default) the model will reply immediately. If
+        false, the model will wait for you to send additional client_content,
+        and will not return until you send `turn_complete=True`.
+
+    Example:
+    ```
+    import google.genai
+    from google.genai import types
+
+    client = genai.Client(http_options={'api_version': 'v1alpha'})
+    async with client.aio.live.connect(
+        model=MODEL_NAME,
+        config={"response_modalities": ["TEXT"]}
+    ) as session:
+      await session.send_client_content(
+          turns=types.Content(
+              role='user',
+              parts=[types.Part(text="Hello world!")]))
+      async for msg in session.receive():
+        if msg.text:
+          print(msg.text)
+    ```
+    """
+    client_content = _t_client_content(turns, turn_complete)
+
+    if self._api_client.vertexai:
+      client_content_dict = _ClientContent_to_vertex(
+          api_client=self._api_client, from_object=client_content
+      )
+    else:
+      client_content_dict = _ClientContent_to_mldev(
+          api_client=self._api_client, from_object=client_content
+      )
+
+    await self._ws.send(json.dumps({'client_content': client_content_dict}))
+
+  async def send_realtime_input(self, *, media: t.BlobUnion):
+    """Send realtime media chunks to the model.
+
+    Use `send_realtime_input` for realtime audio chunks and video
+    frames(images).
+
+    With `send_realtime_input` the api will respond to audio automatically
+    based on voice activity detection (VAD).
+
+    `send_realtime_input` is optimized for responsivness at the expense of
+    deterministic ordering. Audio and video tokens are added to the
+    context when they become available.
+
+    Args:
+      media: A `Blob`-like object, the realtime media to send.
+
+    Example:
+    ```
+    from pathlib import Path
+
+    from google import genai
+    from google.genai import types
+
+    import PIL.Image
+
+    client = genai.Client(http_options= {'api_version': 'v1alpha'})
+
+    async with client.aio.live.connect(
+        model=MODEL_NAME,
+        config={"response_modalities": ["TEXT"]},
+    ) as session:
+      await session.send_realtime_input(
+          media=PIL.Image.open('image.jpg'))
+
+      audio_bytes = Path('audio.pcm').read_bytes()
+      await session.send_realtime_input(
+          media=types.Blob(data=audio_bytes, mime_type='audio/pcm;rate=16000'))
+
+      async for msg in session.receive():
+        if msg.text is not None:
+          print(f'{msg.text}')
+    ```
+    """
+    realtime_input = _t_realtime_input(media)
+    realtime_input_dict = realtime_input.model_dump(
+        exclude_none=True, mode='json'
+    )
+    await self._ws.send(json.dumps({'realtime_input': realtime_input_dict}))
+
+  async def send_tool_response(
+      self,
+      *,
+      function_responses: Union[
+          types.FunctionResponseOrDict,
+          Sequence[types.FunctionResponseOrDict],
+      ],
+  ):
+    """Send a tool response to the session.
+
+    Use `send_tool_response` to reply to `LiveServerToolCall` messages
+    from the server.
+
+    To set the available tools, use the `config.tools` argument
+    when you connect to the session (`client.live.connect`).
+
+    Args:
+      function_responses: A `FunctionResponse`-like object or list of
+        `FunctionResponse`-like objects.
+
+    Example:
+    ```
+    from google import genai
+    from google.genai import types
+
+    client = genai.Client(http_options={'api_version': 'v1alpha'})
+
+    tools = [{'function_declarations': [{'name': 'turn_on_the_lights'}]}]
+    config = {
+        "tools": tools,
+        "response_modalities": ['TEXT']
+    }
+
+    async with client.aio.live.connect(
+        model='gemini-2.0-flash-exp',
+        config=config
+    ) as session:
+      prompt = "Turn on the lights please"
+      await session.send_client_content(
+          turns=prompt,
+          turn_complete=True)
+
+      async for chunk in session.receive():
+          if chunk.server_content:
+            if chunk.text is not None:
+              print(chunk.text)
+          elif chunk.tool_call:
+            print(chunk.tool_call)
+            print('_'*80)
+            function_response=types.FunctionResponse(
+                    name='turn_on_the_lights',
+                    response={'result': 'ok'},
+                    id=chunk.tool_call.function_calls[0].id,
+                )
+            print(function_response)
+            await session.send_tool_response(
+                function_responses=function_response
+            )
+
+            print('_'*80)
+    """
+    tool_response = _t_tool_response(function_responses)
+    if self._api_client.vertexai:
+      tool_response_dict = _ToolResponse_to_vertex(
+          api_client=self._api_client, from_object=tool_response
+      )
+    else:
+      tool_response_dict = _ToolResponse_to_mldev(
+          api_client=self._api_client, from_object=tool_response
+      )
+    await self._ws.send(json.dumps({'tool_response': tool_response_dict}))
+
   async def receive(self) -> AsyncIterator[types.LiveServerMessage]:
     """Receive model responses from the server.
 
@@ -120,8 +395,6 @@ class AsyncSession:
     is function call, user must call `send` with the function response to
     continue the turn.
 
-    The live module is experimental.
-
     Yields:
       The model responses from the server.
 
@@ -146,15 +419,18 @@ class AsyncSession:
   async def start_stream(
       self, *, stream: AsyncIterator[bytes], mime_type: str
   ) -> AsyncIterator[types.LiveServerMessage]:
-    """start a live session from a data stream.
+    """[Deprecated] Start a live session from a data stream.
+
+    > **Warning**: This method is deprecated and will be removed in a future
+    version (not before Q2 2025). Please use one of the more specific methods:
+    `send_client_content`, `send_realtime_input`, or `send_tool_response`
+    instead.
 
     The interaction terminates when the input stream is complete.
     This method will start two async tasks. One task will be used to send the
     input stream to the model and the other task will be used to receive the
     responses from the model.
 
-    The live module is experimental.
-
     Args:
       stream: An iterator that yields the model response.
       mime_type: The MIME type of the data in the stream.
@@ -177,6 +453,13 @@ class AsyncSession:
         mime_type = 'audio/pcm'):
           play_audio_chunk(audio.data)
     """
+    warnings.warn(
+        'Setting `AsyncSession.start_stream` is deprecated, '
+        'and will be removed in a future release (not before Q3 2025). '
+        'Please use the `receive`, and `send_realtime_input`, methods instead.',
+        DeprecationWarning,
+        stacklevel=4,
+    )
     stop_event = asyncio.Event()
     # Start the send loop. When stream is complete stop_event is set.
     asyncio.create_task(self._send_loop(stream, mime_type, stop_event))
@@ -207,7 +490,10 @@ class AsyncSession:
 
   async def _receive(self) -> types.LiveServerMessage:
     parameter_model = types.LiveServerMessage()
-    raw_response = await self._ws.recv(decode=False)
+    try:
+      raw_response = await self._ws.recv(decode=False)
+    except TypeError:
+      raw_response = await self._ws.recv()  # type: ignore[assignment]
     if raw_response:
       try:
         response = json.loads(raw_response)
@@ -215,6 +501,7 @@ class AsyncSession:
         raise ValueError(f'Failed to parse response: {raw_response!r}')
     else:
       response = {}
+
     if self._api_client.vertexai:
       response_dict = self._LiveServerMessage_from_vertex(response)
     else:
@@ -256,6 +543,24 @@ class AsyncSession:
       )
     if getv(from_object, ['turnComplete']) is not None:
       setv(to_object, ['turn_complete'], getv(from_object, ['turnComplete']))
+    if getv(from_object, ['generationComplete']) is not None:
+      setv(
+          to_object,
+          ['generation_complete'],
+          getv(from_object, ['generationComplete']),
+      )
+    if getv(from_object, ['inputTranscription']) is not None:
+      setv(
+          to_object,
+          ['input_transcription'],
+          getv(from_object, ['inputTranscription']),
+      )
+    if getv(from_object, ['outputTranscription']) is not None:
+      setv(
+          to_object,
+          ['output_transcription'],
+          getv(from_object, ['outputTranscription']),
+      )
     if getv(from_object, ['interrupted']) is not None:
       setv(to_object, ['interrupted'], getv(from_object, ['interrupted']))
     return to_object
@@ -286,6 +591,128 @@ class AsyncSession:
       )
     return to_object
 
+  def _LiveServerGoAway_from_mldev(
+      self,
+      from_object: Union[dict, object],
+      parent_object: Optional[dict] = None,
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['timeLeft']) is not None:
+      setv(to_object, ['time_left'], getv(from_object, ['timeLeft']))
+
+    return to_object
+
+  def _LiveServerSessionResumptionUpdate_from_mldev(
+      self,
+      from_object: Union[dict, object],
+      parent_object: Optional[dict] = None,
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['newHandle']) is not None:
+      setv(to_object, ['new_handle'], getv(from_object, ['newHandle']))
+
+    if getv(from_object, ['resumable']) is not None:
+      setv(to_object, ['resumable'], getv(from_object, ['resumable']))
+
+    if getv(from_object, ['lastConsumedClientMessageIndex']) is not None:
+      setv(
+          to_object,
+          ['last_consumed_client_message_index'],
+          getv(from_object, ['lastConsumedClientMessageIndex']),
+      )
+
+    return to_object
+
+  def _ModalityTokenCount_from_mldev(
+      self,
+      from_object: Union[dict, object],
+  ) -> Dict[str, Any]:
+    to_object: Dict[str, Any] = {}
+    if getv(from_object, ['modality']) is not None:
+      setv(to_object, ['modality'], getv(from_object, ['modality']))
+    if getv(from_object, ['tokenCount']) is not None:
+      setv(to_object, ['token_count'], getv(from_object, ['tokenCount']))
+    return to_object
+
+  def _UsageMetadata_from_mldev(
+      self,
+      from_object: Union[dict, object],
+  ) -> Dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['promptTokenCount']) is not None:
+      setv(
+          to_object,
+          ['prompt_token_count'],
+          getv(from_object, ['promptTokenCount']),
+      )
+    if getv(from_object, ['cachedContentTokenCount']) is not None:
+      setv(
+          to_object,
+          ['cached_content_token_count'],
+          getv(from_object, ['cachedContentTokenCount']),
+      )
+    if getv(from_object, ['responseTokenCount']) is not None:
+      setv(
+          to_object,
+          ['response_token_count'],
+          getv(from_object, ['responseTokenCount']),
+      )
+    if getv(from_object, ['toolUsePromptTokenCount']) is not None:
+      setv(
+          to_object,
+          ['tool_use_prompt_token_count'],
+          getv(from_object, ['toolUsePromptTokenCount']),
+      )
+    if getv(from_object, ['thoughtsTokenCount']) is not None:
+      setv(
+          to_object,
+          ['thoughts_token_count'],
+          getv(from_object, ['thoughtsTokenCount']),
+      )
+    if getv(from_object, ['totalTokenCount']) is not None:
+      setv(
+          to_object,
+          ['total_token_count'],
+          getv(from_object, ['totalTokenCount']),
+      )
+    if getv(from_object, ['promptTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['prompt_tokens_details'],
+          [
+              self._ModalityTokenCount_from_mldev(item)
+              for item in getv(from_object, ['promptTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['cacheTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['cache_tokens_details'],
+          [
+              self._ModalityTokenCount_from_mldev(item)
+              for item in getv(from_object, ['cacheTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['responseTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['response_tokens_details'],
+          [
+              self._ModalityTokenCount_from_mldev(item)
+              for item in getv(from_object, ['responseTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['toolUsePromptTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['tool_use_prompt_tokens_details'],
+          [
+              self._ModalityTokenCount_from_mldev(item)
+              for item in getv(from_object, ['toolUsePromptTokensDetails'])
+          ],
+      )
+    return to_object
+
   def _LiveServerMessage_from_mldev(
       self,
       from_object: Union[dict, object],
@@ -311,6 +738,34 @@ class AsyncSession:
           ['tool_call_cancellation'],
           getv(from_object, ['toolCallCancellation']),
       )
+
+    if getv(from_object, ['goAway']) is not None:
+      setv(
+          to_object,
+          ['go_away'],
+          self._LiveServerGoAway_from_mldev(
+              getv(from_object, ['goAway']), to_object
+          ),
+      )
+
+    if getv(from_object, ['sessionResumptionUpdate']) is not None:
+      setv(
+          to_object,
+          ['session_resumption_update'],
+          self._LiveServerSessionResumptionUpdate_from_mldev(
+              getv(from_object, ['sessionResumptionUpdate']),
+              to_object,
+          ),
+      )
+
+      return to_object
+
+    if getv(from_object, ['usageMetadata']) is not None:
+      setv(
+          to_object,
+          ['usage_metadata'],
+          self._UsageMetadata_from_mldev(getv(from_object, ['usageMetadata'])),
+      )
     return to_object
 
   def _LiveServerContent_from_vertex(
@@ -329,10 +784,155 @@ class AsyncSession:
       )
     if getv(from_object, ['turnComplete']) is not None:
       setv(to_object, ['turn_complete'], getv(from_object, ['turnComplete']))
+    if getv(from_object, ['generationComplete']) is not None:
+      setv(
+          to_object,
+          ['generation_complete'],
+          getv(from_object, ['generationComplete']),
+      )
+    if getv(from_object, ['inputTranscription']) is not None:
+      setv(
+          to_object,
+          ['input_transcription'],
+          getv(from_object, ['inputTranscription']),
+      )
+    if getv(from_object, ['outputTranscription']) is not None:
+      setv(
+          to_object,
+          ['output_transcription'],
+          getv(from_object, ['outputTranscription']),
+      )
     if getv(from_object, ['interrupted']) is not None:
       setv(to_object, ['interrupted'], getv(from_object, ['interrupted']))
     return to_object
 
+  def _LiveServerGoAway_from_vertex(
+      self,
+      from_object: Union[dict, object],
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['timeLeft']) is not None:
+      setv(to_object, ['time_left'], getv(from_object, ['timeLeft']))
+
+    return to_object
+
+  def _LiveServerSessionResumptionUpdate_from_vertex(
+      self,
+      from_object: Union[dict, object],
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['newHandle']) is not None:
+      setv(to_object, ['new_handle'], getv(from_object, ['newHandle']))
+
+    if getv(from_object, ['resumable']) is not None:
+      setv(to_object, ['resumable'], getv(from_object, ['resumable']))
+
+    if getv(from_object, ['lastConsumedClientMessageIndex']) is not None:
+      setv(
+          to_object,
+          ['last_consumed_client_message_index'],
+          getv(from_object, ['lastConsumedClientMessageIndex']),
+      )
+
+    return to_object
+
+
+  def _ModalityTokenCount_from_vertex(
+      self,
+      from_object: Union[dict, object],
+  ) -> Dict[str, Any]:
+    to_object: Dict[str, Any] = {}
+    if getv(from_object, ['modality']) is not None:
+      setv(to_object, ['modality'], getv(from_object, ['modality']))
+    if getv(from_object, ['tokenCount']) is not None:
+      setv(to_object, ['token_count'], getv(from_object, ['tokenCount']))
+    return to_object
+
+  def _UsageMetadata_from_vertex(
+      self,
+      from_object: Union[dict, object],
+  ) -> Dict[str, Any]:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['promptTokenCount']) is not None:
+      setv(
+          to_object,
+          ['prompt_token_count'],
+          getv(from_object, ['promptTokenCount']),
+      )
+    if getv(from_object, ['cachedContentTokenCount']) is not None:
+      setv(
+          to_object,
+          ['cached_content_token_count'],
+          getv(from_object, ['cachedContentTokenCount']),
+      )
+    if getv(from_object, ['candidatesTokenCount']) is not None:
+      setv(
+          to_object,
+          ['response_token_count'],
+          getv(from_object, ['candidatesTokenCount']),
+      )
+    if getv(from_object, ['toolUsePromptTokenCount']) is not None:
+      setv(
+          to_object,
+          ['tool_use_prompt_token_count'],
+          getv(from_object, ['toolUsePromptTokenCount']),
+      )
+    if getv(from_object, ['thoughtsTokenCount']) is not None:
+      setv(
+          to_object,
+          ['thoughts_token_count'],
+          getv(from_object, ['thoughtsTokenCount']),
+      )
+    if getv(from_object, ['totalTokenCount']) is not None:
+      setv(
+          to_object,
+          ['total_token_count'],
+          getv(from_object, ['totalTokenCount']),
+      )
+    if getv(from_object, ['promptTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['prompt_tokens_details'],
+          [
+              self._ModalityTokenCount_from_vertex(item)
+              for item in getv(from_object, ['promptTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['cacheTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['cache_tokens_details'],
+          [
+              self._ModalityTokenCount_from_vertex(item)
+              for item in getv(from_object, ['cacheTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['toolUsePromptTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['tool_use_prompt_tokens_details'],
+          [
+              self._ModalityTokenCount_from_vertex(item)
+              for item in getv(from_object, ['toolUsePromptTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['candidatesTokensDetails']) is not None:
+      setv(
+          to_object,
+          ['response_tokens_details'],
+          [
+              self._ModalityTokenCount_from_vertex(item)
+              for item in getv(from_object, ['candidatesTokensDetails'])
+          ],
+      )
+    if getv(from_object, ['trafficType']) is not None:
+      setv(
+          to_object,
+          ['traffic_type'],
+          getv(from_object, ['trafficType']),
+      )
+    return to_object
+
   def _LiveServerMessage_from_vertex(
       self,
       from_object: Union[dict, object],
@@ -346,7 +946,6 @@ class AsyncSession:
               getv(from_object, ['serverContent'])
           ),
       )
-
     if getv(from_object, ['toolCall']) is not None:
       setv(
           to_object,
@@ -359,6 +958,31 @@ class AsyncSession:
           ['tool_call_cancellation'],
           getv(from_object, ['toolCallCancellation']),
       )
+
+    if getv(from_object, ['goAway']) is not None:
+      setv(
+          to_object,
+          ['go_away'],
+          self._LiveServerGoAway_from_vertex(
+              getv(from_object, ['goAway'])
+          ),
+      )
+
+    if getv(from_object, ['sessionResumptionUpdate']) is not None:
+      setv(
+          to_object,
+          ['session_resumption_update'],
+          self._LiveServerSessionResumptionUpdate_from_vertex(
+              getv(from_object, ['sessionResumptionUpdate']),
+          ),
+      )
+
+    if getv(from_object, ['usageMetadata']) is not None:
+      setv(
+          to_object,
+          ['usage_metadata'],
+          self._UsageMetadata_from_vertex(getv(from_object, ['usageMetadata'])),
+      )
     return to_object
 
   def _parse_client_message(
@@ -669,8 +1293,81 @@ class AsyncSession:
     await self._ws.close()
 
 
+def _t_content_strict(content: types.ContentOrDict):
+  if isinstance(content, dict):
+    return types.Content.model_validate(content)
+  elif isinstance(content, types.Content):
+    return content
+  else:
+    raise ValueError(
+        f'Could not convert input (type "{type(content)}") to '
+        '`types.Content`'
+    )
+
+
+def _t_contents_strict(
+    contents: Union[Sequence[types.ContentOrDict], types.ContentOrDict]):
+  if isinstance(contents, Sequence):
+    return [_t_content_strict(content) for content in contents]
+  else:
+    return [_t_content_strict(contents)]
+
+
+def _t_client_content(
+    turns: Optional[
+        Union[Sequence[types.ContentOrDict], types.ContentOrDict]
+    ] = None,
+    turn_complete: bool = True,
+) -> types.LiveClientContent:
+  if turns is None:
+    return types.LiveClientContent(turn_complete=turn_complete)
+
+  try:
+    return types.LiveClientContent(
+        turns=_t_contents_strict(contents=turns),
+        turn_complete=turn_complete,
+    )
+  except Exception as e:
+    raise ValueError(
+        f'Could not convert input (type "{type(turns)}") to '
+        '`types.LiveClientContent`'
+    ) from e
+
+
+def _t_realtime_input(
+    media: t.BlobUnion,
+) -> types.LiveClientRealtimeInput:
+  try:
+    return types.LiveClientRealtimeInput(media_chunks=[t.t_blob(blob=media)])
+  except Exception as e:
+    raise ValueError(
+        f'Could not convert input (type "{type(input)}") to '
+        '`types.LiveClientRealtimeInput`'
+    ) from e
+
+
+def _t_tool_response(
+    input: Union[
+        types.FunctionResponseOrDict,
+        Sequence[types.FunctionResponseOrDict],
+    ],
+) -> types.LiveClientToolResponse:
+  if not input:
+    raise ValueError(f'A tool response is required, got: \n{input}')
+
+  try:
+    return types.LiveClientToolResponse(
+        function_responses=t.t_function_responses(function_responses=input)
+    )
+  except Exception as e:
+    raise ValueError(
+        f'Could not convert input (type "{type(input)}") to '
+        '`types.LiveClientToolResponse`'
+    ) from e
+
+
 class AsyncLive(_api_module.BaseModule):
-  """AsyncLive. The live module is experimental."""
+  """[Preview] AsyncLive."""
 
   def _LiveSetup_to_mldev(
       self, model: str, config: Optional[types.LiveConnectConfig] = None
@@ -715,7 +1412,48 @@ class AsyncLive(_api_module.BaseModule):
                 to_object,
             )
         }
-
+    if getv(config, ['temperature']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['temperature'] = getv(
+            config, ['temperature']
+        )
+      else:
+        to_object['generationConfig'] = {
+            'temperature': getv(config, ['temperature'])
+        }
+    if getv(config, ['top_p']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['topP'] = getv(config, ['top_p'])
+      else:
+        to_object['generationConfig'] = {'topP': getv(config, ['top_p'])}
+    if getv(config, ['top_k']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['topK'] = getv(config, ['top_k'])
+      else:
+        to_object['generationConfig'] = {'topK': getv(config, ['top_k'])}
+    if getv(config, ['max_output_tokens']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['maxOutputTokens'] = getv(
+            config, ['max_output_tokens']
+        )
+      else:
+        to_object['generationConfig'] = {
+            'maxOutputTokens': getv(config, ['max_output_tokens'])
+        }
+    if getv(config, ['media_resolution']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['mediaResolution'] = getv(
+            config, ['media_resolution']
+        )
+      else:
+        to_object['generationConfig'] = {
+            'mediaResolution': getv(config, ['media_resolution'])
+        }
+    if getv(config, ['seed']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['seed'] = getv(config, ['seed'])
+      else:
+        to_object['generationConfig'] = {'seed': getv(config, ['seed'])}
     if getv(config, ['system_instruction']) is not None:
       setv(
           to_object,
@@ -739,11 +1477,84 @@ class AsyncLive(_api_module.BaseModule):
               for item in t.t_tools(self._api_client, getv(config, ['tools']))
           ],
       )
+    if getv(config, ['input_audio_transcription']) is not None:
+      raise ValueError('input_audio_transcription is not supported in MLDev '
+                       'API.')
+    if getv(config, ['output_audio_transcription']) is not None:
+      setv(
+          to_object,
+          ['outputAudioTranscription'],
+          _AudioTranscriptionConfig_to_mldev(
+              self._api_client,
+              getv(config, ['output_audio_transcription']),
+          ),
+      )
+
+    if getv(config, ['session_resumption']) is not None:
+      setv(
+          to_object,
+          ['sessionResumption'],
+          self._LiveClientSessionResumptionConfig_to_mldev(
+              getv(config, ['session_resumption'])
+          ),
+      )
+
+    if getv(config, ['context_window_compression']) is not None:
+      setv(
+          to_object,
+          ['contextWindowCompression'],
+          self._ContextWindowCompressionConfig_to_mldev(
+              getv(config, ['context_window_compression']),
+          ),
+      )
 
     return_value = {'setup': {'model': model}}
     return_value['setup'].update(to_object)
     return return_value
 
+  def _SlidingWindow_to_mldev(
+      self,
+      from_object: Union[dict, object],
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['target_tokens']) is not None:
+      setv(to_object, ['targetTokens'], getv(from_object, ['target_tokens']))
+
+    return to_object
+
+
+  def _ContextWindowCompressionConfig_to_mldev(
+      self,
+      from_object: Union[dict, object],
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['trigger_tokens']) is not None:
+      setv(to_object, ['triggerTokens'], getv(from_object, ['trigger_tokens']))
+
+    if getv(from_object, ['sliding_window']) is not None:
+      setv(
+          to_object,
+          ['slidingWindow'],
+          self._SlidingWindow_to_mldev(
+              getv(from_object, ['sliding_window'])
+          ),
+      )
+
+    return to_object
+
+  def _LiveClientSessionResumptionConfig_to_mldev(
+      self,
+      from_object: Union[dict, object]
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['handle']) is not None:
+      setv(to_object, ['handle'], getv(from_object, ['handle']))
+
+    if getv(from_object, ['transparent']) is not None:
+      raise ValueError('The `transparent` field is not supported in MLDev API')
+
+    return to_object
+
   def _LiveSetup_to_vertex(
       self, model: str, config: Optional[types.LiveConnectConfig] = None
   ):
@@ -796,6 +1607,48 @@ class AsyncLive(_api_module.BaseModule):
                 to_object,
             )
         }
+    if getv(config, ['temperature']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['temperature'] = getv(
+            config, ['temperature']
+        )
+      else:
+        to_object['generationConfig'] = {
+            'temperature': getv(config, ['temperature'])
+        }
+    if getv(config, ['top_p']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['topP'] = getv(config, ['top_p'])
+      else:
+        to_object['generationConfig'] = {'topP': getv(config, ['top_p'])}
+    if getv(config, ['top_k']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['topK'] = getv(config, ['top_k'])
+      else:
+        to_object['generationConfig'] = {'topK': getv(config, ['top_k'])}
+    if getv(config, ['max_output_tokens']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['maxOutputTokens'] = getv(
+            config, ['max_output_tokens']
+        )
+      else:
+        to_object['generationConfig'] = {
+            'maxOutputTokens': getv(config, ['max_output_tokens'])
+        }
+    if getv(config, ['media_resolution']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['mediaResolution'] = getv(
+            config, ['media_resolution']
+        )
+      else:
+        to_object['generationConfig'] = {
+            'mediaResolution': getv(config, ['media_resolution'])
+        }
+    if getv(config, ['seed']) is not None:
+      if getv(to_object, ['generationConfig']) is not None:
+        to_object['generationConfig']['seed'] = getv(config, ['seed'])
+      else:
+        to_object['generationConfig'] = {'seed': getv(config, ['seed'])}
     if getv(config, ['system_instruction']) is not None:
       setv(
           to_object,
@@ -819,14 +1672,89 @@ class AsyncLive(_api_module.BaseModule):
               for item in t.t_tools(self._api_client, getv(config, ['tools']))
           ],
       )
+    if getv(config, ['input_audio_transcription']) is not None:
+      setv(
+          to_object,
+          ['inputAudioTranscription'],
+          _AudioTranscriptionConfig_to_vertex(
+              self._api_client,
+              getv(config, ['input_audio_transcription']),
+          ),
+      )
+    if getv(config, ['output_audio_transcription']) is not None:
+      setv(
+          to_object,
+          ['outputAudioTranscription'],
+          _AudioTranscriptionConfig_to_vertex(
+              self._api_client,
+              getv(config, ['output_audio_transcription']),
+          ),
+      )
+
+    if getv(config, ['session_resumption']) is not None:
+      setv(
+          to_object,
+          ['sessionResumption'],
+          self._LiveClientSessionResumptionConfig_to_vertex(
+              getv(config, ['session_resumption'])
+          ),
+      )
+
+    if getv(config, ['context_window_compression']) is not None:
+      setv(
+          to_object,
+          ['contextWindowCompression'],
+          self._ContextWindowCompressionConfig_to_vertex(
+              getv(config, ['context_window_compression']),
+          ),
+      )
 
     return_value = {'setup': {'model': model}}
     return_value['setup'].update(to_object)
     return return_value
 
-  @experimental_warning(
-      'The live API is experimental and may change in future versions.',
-  )
+  def _SlidingWindow_to_vertex(
+      self,
+      from_object: Union[dict, object],
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['target_tokens']) is not None:
+      setv(to_object, ['targetTokens'], getv(from_object, ['target_tokens']))
+
+    return to_object
+
+  def _ContextWindowCompressionConfig_to_vertex(
+      self,
+      from_object: Union[dict, object],
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['trigger_tokens']) is not None:
+      setv(to_object, ['triggerTokens'], getv(from_object, ['trigger_tokens']))
+
+    if getv(from_object, ['sliding_window']) is not None:
+      setv(
+          to_object,
+          ['slidingWindow'],
+          self._SlidingWindow_to_mldev(
+              getv(from_object, ['sliding_window'])
+          ),
+      )
+
+    return to_object
+
+  def _LiveClientSessionResumptionConfig_to_vertex(
+      self,
+      from_object: Union[dict, object]
+  ) -> dict:
+    to_object: dict[str, Any] = {}
+    if getv(from_object, ['handle']) is not None:
+      setv(to_object, ['handle'], getv(from_object, ['handle']))
+
+    if getv(from_object, ['transparent']) is not None:
+      setv(to_object, ['transparent'], getv(from_object, ['transparent']))
+
+    return to_object
+
   @contextlib.asynccontextmanager
   async def connect(
       self,
@@ -834,9 +1762,9 @@ class AsyncLive(_api_module.BaseModule):
       model: str,
       config: Optional[types.LiveConnectConfigOrDict] = None,
   ) -> AsyncIterator[AsyncSession]:
-    """Connect to the live server.
+    """[Preview] Connect to the live server.
 
-    The live module is experimental.
+    Note: the live API is currently in preview.
 
     Usage:
 
@@ -851,25 +1779,8 @@ class AsyncLive(_api_module.BaseModule):
     """
     base_url = self._api_client._websocket_base_url()
     transformed_model = t.t_model(self._api_client, model)
-    # Ensure the config is a LiveConnectConfig.
-    if config is None:
-      parameter_model = types.LiveConnectConfig()
-    elif isinstance(config, dict):
-      if config.get('system_instruction') is None:
-        system_instruction = None
-      else:
-        system_instruction = t.t_content(
-            self._api_client, config.get('system_instruction')
-        )
-      parameter_model = types.LiveConnectConfig(
-          generation_config=config.get('generation_config'),
-          response_modalities=config.get('response_modalities'),
-          speech_config=config.get('speech_config'),
-          system_instruction=system_instruction,
-          tools=config.get('tools'),
-      )
-    else:
-      parameter_model = config
+
+    parameter_model = _t_live_connect_config(self._api_client, config)
 
     if self._api_client.api_key:
       api_key = self._api_client.api_key
@@ -915,8 +1826,50 @@ class AsyncLive(_api_module.BaseModule):
       )
       request = json.dumps(request_dict)
 
-    async with connect(uri, additional_headers=headers) as ws:
-      await ws.send(request)
-      logger.info(await ws.recv(decode=False))
+    try:
+      async with connect(uri, additional_headers=headers) as ws:
+        await ws.send(request)
+        logger.info(await ws.recv(decode=False))
+
+        yield AsyncSession(api_client=self._api_client, websocket=ws)
+    except TypeError:
+      # Try with the older websockets API
+      async with connect(uri, extra_headers=headers) as ws:
+        await ws.send(request)
+        logger.info(await ws.recv())
+
+        yield AsyncSession(api_client=self._api_client, websocket=ws)
+
+
+def _t_live_connect_config(
+    api_client: BaseApiClient,
+    config: Optional[types.LiveConnectConfigOrDict],
+) -> types.LiveConnectConfig:
+  # Ensure the config is a LiveConnectConfig.
+  if config is None:
+    parameter_model = types.LiveConnectConfig()
+  elif isinstance(config, dict):
+    system_instruction = config.pop('system_instruction', None)
+    if system_instruction is not None:
+      converted_system_instruction = t.t_content(
+          api_client, content=system_instruction
+      )
+    else:
+      converted_system_instruction = None
+    parameter_model = types.LiveConnectConfig(
+        system_instruction=converted_system_instruction,
+        **config
+    )  # type: ignore
+  else:
+    parameter_model = config
+
+  if parameter_model.generation_config is not None:
+    warnings.warn(
+        'Setting `LiveConnectConfig.generation_config` is deprecated, '
+        'please set the fields on `LiveConnectConfig` directly. This will '
+        'become an error in a future version (not before Q3 2025)',
+        DeprecationWarning,
+        stacklevel=4,
+    )
 
-      yield AsyncSession(api_client=self._api_client, websocket=ws)
+  return parameter_model