google-genai 1.7.0__py3-none-any.whl → 1.53.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,16 @@
 # 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
+import typing
+from typing import Any, AsyncIterator, Optional, Sequence, Union, get_args
+import warnings
 
 import google.auth
 import pydantic
@@ -28,34 +30,50 @@ from websockets import ConnectionClosed
 
 from . import _api_module
 from . import _common
+from . import _live_converters as live_converters
+from . import _mcp_utils
 from . import _transformers as t
-from . import client
 from . import errors
 from . import types
 from ._api_client import BaseApiClient
-from ._common import experimental_warning
 from ._common import get_value_by_path as getv
 from ._common import set_value_by_path as setv
-from .models import _Content_from_mldev
-from .models import _Content_from_vertex
+from .live_music import AsyncLiveMusic
 from .models import _Content_to_mldev
-from .models import _Content_to_vertex
-from .models import _GenerateContentConfig_to_mldev
-from .models import _GenerateContentConfig_to_vertex
-from .models import _SafetySetting_to_mldev
-from .models import _SafetySetting_to_vertex
-from .models import _SpeechConfig_to_mldev
-from .models import _SpeechConfig_to_vertex
-from .models import _Tool_to_mldev
-from .models import _Tool_to_vertex
+
 
 try:
-  from websockets.asyncio.client import ClientConnection  # type: ignore
-  from websockets.asyncio.client import connect  # type: ignore
+  from websockets.asyncio.client import ClientConnection
+  from websockets.asyncio.client import connect as ws_connect
 except ModuleNotFoundError:
   # This try/except is for TAP, mypy complains about it which is why we have the type: ignore
   from websockets.client import ClientConnection  # type: ignore
-  from websockets.client import connect  # type: ignore
+  from websockets.client import connect as ws_connect  # type: ignore
+
+try:
+  from google.auth.transport import requests
+except ImportError:
+  requests = None  # type: ignore[assignment]
+
+if typing.TYPE_CHECKING:
+  from mcp import ClientSession as McpClientSession
+  from mcp.types import Tool as McpTool
+  from ._adapters import McpToGenAiToolAdapter
+  from ._mcp_utils import mcp_to_gemini_tool
+else:
+  McpClientSession: typing.Type = Any
+  McpTool: typing.Type = Any
+  McpToGenAiToolAdapter: typing.Type = Any
+  try:
+    from mcp import ClientSession as McpClientSession
+    from mcp.types import Tool as McpTool
+    from ._adapters import McpToGenAiToolAdapter
+    from ._mcp_utils import mcp_to_gemini_tool
+  except ImportError:
+    McpClientSession = None
+    McpTool = None
+    McpToGenAiToolAdapter = None
+    mcp_to_gemini_tool = None
 
 logger = logging.getLogger('google_genai.live')
 
@@ -66,13 +84,17 @@ _FUNCTION_RESPONSE_REQUIRES_ID = (
 
 
 class AsyncSession:
-  """AsyncSession. The live module is experimental."""
+  """[Preview] AsyncSession."""
 
   def __init__(
-      self, api_client: client.BaseApiClient, websocket: ClientConnection
+      self,
+      api_client: BaseApiClient,
+      websocket: ClientConnection,
+      session_id: Optional[str] = None,
   ):
     self._api_client = api_client
     self._ws = websocket
+    self.session_id = session_id
 
   async def send(
       self,
@@ -89,8 +111,13 @@ class AsyncSession:
           ]
       ] = None,
       end_of_turn: Optional[bool] = False,
-  ):
-    """Send input to the model.
+  ) -> None:
+    """[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 +136,297 @@ 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,
+  ) -> None:
+    """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:
+
+    .. code-block:: python
+
+      import google.genai
+      from google.genai import types
+      import os
+
+      if os.environ.get('GOOGLE_GENAI_USE_VERTEXAI'):
+        MODEL_NAME = 'gemini-2.0-flash-live-preview-04-09'
+      else:
+        MODEL_NAME = 'gemini-live-2.5-flash-preview';
+
+      client = genai.Client()
+      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.t_client_content(turns, turn_complete).model_dump(
+        mode='json', exclude_none=True
+    )
+
+    if self._api_client.vertexai:
+      client_content_dict = _common.convert_to_dict(
+          client_content, convert_keys=True
+      )
+    else:
+      client_content_dict = live_converters._LiveClientContent_to_mldev(
+          from_object=client_content
+      )
+
+    await self._ws.send(json.dumps({'client_content': client_content_dict}))
+
+  async def send_realtime_input(
+      self,
+      *,
+      media: Optional[types.BlobImageUnionDict] = None,
+      audio: Optional[types.BlobOrDict] = None,
+      audio_stream_end: Optional[bool] = None,
+      video: Optional[types.BlobImageUnionDict] = None,
+      text: Optional[str] = None,
+      activity_start: Optional[types.ActivityStartOrDict] = None,
+      activity_end: Optional[types.ActivityEndOrDict] = None,
+  ) -> None:
+    """Send realtime input to the model, only send one argument per call.
+
+    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:
+
+    .. code-block:: python
+
+      from pathlib import Path
+
+      from google import genai
+      from google.genai import types
+
+      import PIL.Image
+
+      import os
+
+      if os.environ.get('GOOGLE_GENAI_USE_VERTEXAI'):
+        MODEL_NAME = 'gemini-2.0-flash-live-preview-04-09'
+      else:
+        MODEL_NAME = 'gemini-live-2.5-flash-preview';
+
+
+      client = genai.Client()
+
+      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}')
+    """
+    kwargs: _common.StringDict = {}
+    if media is not None:
+      kwargs['media'] = media
+    if audio is not None:
+      kwargs['audio'] = audio
+    if audio_stream_end is not None:
+      kwargs['audio_stream_end'] = audio_stream_end
+    if video is not None:
+      kwargs['video'] = video
+    if text is not None:
+      kwargs['text'] = text
+    if activity_start is not None:
+      kwargs['activity_start'] = activity_start
+    if activity_end is not None:
+      kwargs['activity_end'] = activity_end
+
+    if len(kwargs) != 1:
+      raise ValueError(
+          f'Only one argument can be set, got {len(kwargs)}:'
+          f' {list(kwargs.keys())}'
+      )
+    realtime_input = types.LiveSendRealtimeInputParameters.model_validate(
+        kwargs
+    )
+
+    if self._api_client.vertexai:
+      realtime_input_dict = (
+          live_converters._LiveSendRealtimeInputParameters_to_vertex(
+              from_object=realtime_input
+          )
+      )
+    else:
+      realtime_input_dict = (
+          live_converters._LiveSendRealtimeInputParameters_to_mldev(
+              from_object=realtime_input
+          )
+      )
+    realtime_input_dict = _common.convert_to_dict(realtime_input_dict)
+    realtime_input_dict = _common.encode_unserializable_types(
+        realtime_input_dict
+    )
+    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],
+      ],
+  ) -> None:
+    """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:
+
+    .. code-block:: python
+
+      from google import genai
+      from google.genai import types
+
+      import os
+
+      if os.environ.get('GOOGLE_GENAI_USE_VERTEXAI'):
+        MODEL_NAME = 'gemini-2.0-flash-live-preview-04-09'
+      else:
+        MODEL_NAME = 'gemini-live-2.5-flash-preview';
+
+      client = genai.Client()
+
+      tools = [{'function_declarations': [{'name': 'turn_on_the_lights'}]}]
+      config = {
+          "tools": tools,
+          "response_modalities": ['TEXT']
+      }
+
+      async with client.aio.live.connect(
+          model='models/gemini-live-2.5-flash-preview',
+          config=config
+      ) as session:
+        prompt = "Turn on the lights please"
+        await session.send_client_content(
+            turns={"parts": [{'text': prompt}]}
+        )
+
+        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.t_tool_response(function_responses)
+    if self._api_client.vertexai:
+      tool_response_dict = _common.convert_to_dict(
+          tool_response, convert_keys=True
+      )
+    else:
+      tool_response_dict = _common.convert_to_dict(
+          tool_response, convert_keys=True
+      )
+      for response in tool_response_dict.get('functionResponses', []):
+        if response.get('id') is None:
+          raise ValueError(_FUNCTION_RESPONSE_REQUIRES_ID)
+
+    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 +435,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 +459,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 +493,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 +530,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,10 +541,11 @@ 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)
+      response_dict = live_converters._LiveServerMessage_from_vertex(response)
     else:
-      response_dict = self._LiveServerMessage_from_mldev(response)
+      response_dict = response
 
     return types.LiveServerMessage._from_response(
         response=response_dict, kwargs=parameter_model.model_dump()
@@ -229,10 +556,10 @@ class AsyncSession:
       data_stream: AsyncIterator[bytes],
       mime_type: str,
       stop_event: asyncio.Event,
-  ):
+  ) -> None:
     async for data in data_stream:
       model_input = types.LiveClientRealtimeInput(
-        media_chunks=[types.Blob(data=data, mime_type=mime_type)]
+          media_chunks=[types.Blob(data=data, mime_type=mime_type)]
       )
       await self.send(input=model_input)
       # Give a chance for the receive loop to process responses.
@@ -240,127 +567,6 @@ class AsyncSession:
     # Give a chance for the receiver to process the last response.
     stop_event.set()
 
-  def _LiveServerContent_from_mldev(
-      self,
-      from_object: Union[dict, object],
-  ) -> Dict[str, Any]:
-    to_object: dict[str, Any] = {}
-    if getv(from_object, ['modelTurn']) is not None:
-      setv(
-          to_object,
-          ['model_turn'],
-          _Content_from_mldev(
-              self._api_client,
-              getv(from_object, ['modelTurn']),
-          ),
-      )
-    if getv(from_object, ['turnComplete']) is not None:
-      setv(to_object, ['turn_complete'], getv(from_object, ['turnComplete']))
-    if getv(from_object, ['interrupted']) is not None:
-      setv(to_object, ['interrupted'], getv(from_object, ['interrupted']))
-    return to_object
-
-  def _LiveToolCall_from_mldev(
-      self,
-      from_object: Union[dict, object],
-  ) -> Dict[str, Any]:
-    to_object: dict[str, Any] = {}
-    if getv(from_object, ['functionCalls']) is not None:
-      setv(
-          to_object,
-          ['function_calls'],
-          getv(from_object, ['functionCalls']),
-      )
-    return to_object
-
-  def _LiveToolCall_from_vertex(
-      self,
-      from_object: Union[dict, object],
-  ) -> Dict[str, Any]:
-    to_object: dict[str, Any] = {}
-    if getv(from_object, ['functionCalls']) is not None:
-      setv(
-          to_object,
-          ['function_calls'],
-          getv(from_object, ['functionCalls']),
-      )
-    return to_object
-
-  def _LiveServerMessage_from_mldev(
-      self,
-      from_object: Union[dict, object],
-  ) -> Dict[str, Any]:
-    to_object: dict[str, Any] = {}
-    if getv(from_object, ['serverContent']) is not None:
-      setv(
-          to_object,
-          ['server_content'],
-          self._LiveServerContent_from_mldev(
-              getv(from_object, ['serverContent'])
-          ),
-      )
-    if getv(from_object, ['toolCall']) is not None:
-      setv(
-          to_object,
-          ['tool_call'],
-          self._LiveToolCall_from_mldev(getv(from_object, ['toolCall'])),
-      )
-    if getv(from_object, ['toolCallCancellation']) is not None:
-      setv(
-          to_object,
-          ['tool_call_cancellation'],
-          getv(from_object, ['toolCallCancellation']),
-      )
-    return to_object
-
-  def _LiveServerContent_from_vertex(
-      self,
-      from_object: Union[dict, object],
-  ) -> Dict[str, Any]:
-    to_object: dict[str, Any] = {}
-    if getv(from_object, ['modelTurn']) is not None:
-      setv(
-          to_object,
-          ['model_turn'],
-          _Content_from_vertex(
-              self._api_client,
-              getv(from_object, ['modelTurn']),
-          ),
-      )
-    if getv(from_object, ['turnComplete']) is not None:
-      setv(to_object, ['turn_complete'], getv(from_object, ['turnComplete']))
-    if getv(from_object, ['interrupted']) is not None:
-      setv(to_object, ['interrupted'], getv(from_object, ['interrupted']))
-    return to_object
-
-  def _LiveServerMessage_from_vertex(
-      self,
-      from_object: Union[dict, object],
-  ) -> Dict[str, Any]:
-    to_object: dict[str, Any] = {}
-    if getv(from_object, ['serverContent']) is not None:
-      setv(
-          to_object,
-          ['server_content'],
-          self._LiveServerContent_from_vertex(
-              getv(from_object, ['serverContent'])
-          ),
-      )
-
-    if getv(from_object, ['toolCall']) is not None:
-      setv(
-          to_object,
-          ['tool_call'],
-          self._LiveToolCall_from_vertex(getv(from_object, ['toolCall'])),
-      )
-    if getv(from_object, ['toolCallCancellation']) is not None:
-      setv(
-          to_object,
-          ['tool_call_cancellation'],
-          getv(from_object, ['toolCallCancellation']),
-      )
-    return to_object
-
   def _parse_client_message(
       self,
       input: Optional[
@@ -391,9 +597,8 @@ class AsyncSession:
         raise ValueError(
             f'Unsupported input type "{type(input)}" or input content "{input}"'
         )
-      if (
-          isinstance(blob_input, types.Blob)
-          and isinstance(blob_input.data, bytes)
+      if isinstance(blob_input, types.Blob) and isinstance(
+          blob_input.data, bytes
       ):
         formatted_input = [
             blob_input.model_dump(mode='json', exclude_none=True)
@@ -447,20 +652,20 @@ class AsyncSession:
     elif isinstance(formatted_input, Sequence) and any(
         isinstance(c, str) for c in formatted_input
     ):
-      to_object: dict[str, Any] = {}
+      to_object: _common.StringDict = {}
       content_input_parts: list[types.PartUnion] = []
       for item in formatted_input:
         if isinstance(item, get_args(types.PartUnion)):
           content_input_parts.append(item)
       if self._api_client.vertexai:
         contents = [
-            _Content_to_vertex(self._api_client, item, to_object)
-            for item in t.t_contents(self._api_client, content_input_parts)
+            _common.convert_to_dict(item, convert_keys=True)
+            for item in t.t_contents(content_input_parts)
         ]
       else:
         contents = [
-            _Content_to_mldev(self._api_client, item, to_object)
-            for item in t.t_contents(self._api_client, content_input_parts)
+            _Content_to_mldev(item, to_object)
+            for item in t.t_contents(content_input_parts)
         ]
 
       content_dict_list: list[types.ContentDict] = []
@@ -664,169 +869,22 @@ class AsyncSession:
 
     return client_message
 
-  async def close(self):
+  async def close(self) -> None:
     # Close the websocket connection.
     await self._ws.close()
 
 
 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
-  ):
-
-    to_object: dict[str, Any] = {}
-    if getv(config, ['generation_config']) is not None:
-      setv(
-          to_object,
-          ['generationConfig'],
-          _GenerateContentConfig_to_mldev(
-              self._api_client,
-              getv(config, ['generation_config']),
-              to_object,
-          ),
-      )
-    if getv(config, ['response_modalities']) is not None:
-      if getv(to_object, ['generationConfig']) is not None:
-        to_object['generationConfig']['responseModalities'] = getv(
-            config, ['response_modalities']
-        )
-      else:
-        to_object['generationConfig'] = {
-            'responseModalities': getv(config, ['response_modalities'])
-        }
-    if getv(config, ['speech_config']) is not None:
-      if getv(to_object, ['generationConfig']) is not None:
-        to_object['generationConfig']['speechConfig'] = _SpeechConfig_to_mldev(
-            self._api_client,
-            t.t_speech_config(
-                self._api_client, getv(config, ['speech_config'])
-            ),
-            to_object,
-        )
-      else:
-        to_object['generationConfig'] = {
-            'speechConfig': _SpeechConfig_to_mldev(
-                self._api_client,
-                t.t_speech_config(
-                    self._api_client, getv(config, ['speech_config'])
-                ),
-                to_object,
-            )
-        }
-
-    if getv(config, ['system_instruction']) is not None:
-      setv(
-          to_object,
-          ['systemInstruction'],
-          _Content_to_mldev(
-              self._api_client,
-              t.t_content(
-                  self._api_client, getv(config, ['system_instruction'])
-              ),
-              to_object,
-          ),
-      )
-    if getv(config, ['tools']) is not None:
-      setv(
-          to_object,
-          ['tools'],
-          [
-              _Tool_to_mldev(
-                  self._api_client, t.t_tool(self._api_client, item), to_object
-              )
-              for item in t.t_tools(self._api_client, getv(config, ['tools']))
-          ],
-      )
+  def __init__(self, api_client: BaseApiClient):
+    super().__init__(api_client)
+    self._music = AsyncLiveMusic(api_client)
 
-    return_value = {'setup': {'model': model}}
-    return_value['setup'].update(to_object)
-    return return_value
+  @property
+  def music(self) -> AsyncLiveMusic:
+    return self._music
 
-  def _LiveSetup_to_vertex(
-      self, model: str, config: Optional[types.LiveConnectConfig] = None
-  ):
-
-    to_object: dict[str, Any] = {}
-
-    if getv(config, ['generation_config']) is not None:
-      setv(
-          to_object,
-          ['generationConfig'],
-          _GenerateContentConfig_to_vertex(
-              self._api_client,
-              getv(config, ['generation_config']),
-              to_object,
-          ),
-      )
-    if getv(config, ['response_modalities']) is not None:
-      if getv(to_object, ['generationConfig']) is not None:
-        to_object['generationConfig']['responseModalities'] = getv(
-            config, ['response_modalities']
-        )
-      else:
-        to_object['generationConfig'] = {
-            'responseModalities': getv(config, ['response_modalities'])
-        }
-    else:
-      # Set default to AUDIO to align with MLDev API.
-      if getv(to_object, ['generationConfig']) is not None:
-        to_object['generationConfig'].update({'responseModalities': ['AUDIO']})
-      else:
-        to_object.update(
-            {'generationConfig': {'responseModalities': ['AUDIO']}}
-        )
-    if getv(config, ['speech_config']) is not None:
-      if getv(to_object, ['generationConfig']) is not None:
-        to_object['generationConfig']['speechConfig'] = _SpeechConfig_to_vertex(
-            self._api_client,
-            t.t_speech_config(
-                self._api_client, getv(config, ['speech_config'])
-            ),
-            to_object,
-        )
-      else:
-        to_object['generationConfig'] = {
-            'speechConfig': _SpeechConfig_to_vertex(
-                self._api_client,
-                t.t_speech_config(
-                    self._api_client, getv(config, ['speech_config'])
-                ),
-                to_object,
-            )
-        }
-    if getv(config, ['system_instruction']) is not None:
-      setv(
-          to_object,
-          ['systemInstruction'],
-          _Content_to_vertex(
-              self._api_client,
-              t.t_content(
-                  self._api_client, getv(config, ['system_instruction'])
-              ),
-              to_object,
-          ),
-      )
-    if getv(config, ['tools']) is not None:
-      setv(
-          to_object,
-          ['tools'],
-          [
-              _Tool_to_vertex(
-                  self._api_client, t.t_tool(self._api_client, item), to_object
-              )
-              for item in t.t_tools(self._api_client, getv(config, ['tools']))
-          ],
-      )
-
-    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.',
-  )
   @contextlib.asynccontextmanager
   async def connect(
       self,
@@ -834,9 +892,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:
 
@@ -845,78 +903,270 @@ class AsyncLive(_api_module.BaseModule):
       client = genai.Client(api_key=API_KEY)
       config = {}
       async with client.aio.live.connect(model='...', config=config) as session:
-        await session.send(input='Hello world!', end_of_turn=True)
+        await session.send_client_content(
+          turns=types.Content(
+            role='user',
+            parts=[types.Part(text='hello!')]
+          ),
+          turn_complete=True
+        )
         async for message in session.receive():
           print(message)
+
+    Args:
+      model: The model to use for the live session.
+      config: The configuration for the live session.
+      **kwargs: additional keyword arguments.
+
+    Yields:
+      An AsyncSession object.
     """
+    # TODO(b/404946570): Support per request http options.
+    if isinstance(config, dict):
+      config = types.LiveConnectConfig(**config)
+    if config and config.http_options:
+      raise ValueError(
+          'google.genai.client.aio.live.connect() does not support'
+          ' http_options at request-level in LiveConnectConfig yet. Please use'
+          ' the client-level http_options configuration instead.'
+      )
+
     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')
+    if isinstance(base_url, bytes):
+      base_url = base_url.decode('utf-8')
+    transformed_model = t.t_model(self._api_client, model)  # type: ignore
+
+    parameter_model = await _t_live_connect_config(self._api_client, config)
+
+    if self._api_client.api_key and not self._api_client.vertexai:
+      version = self._api_client._http_options.api_version
+      api_key = self._api_client.api_key
+      method = 'BidiGenerateContent'
+      original_headers = self._api_client._http_options.headers
+      headers = original_headers.copy() if original_headers is not None else {}
+      if api_key.startswith('auth_tokens/'):
+        warnings.warn(
+            message=(
+                "The SDK's ephemeral token support is experimental, and may"
+                ' change in future versions.'
+            ),
+            category=errors.ExperimentalWarning,
         )
-      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'),
+        method = 'BidiGenerateContentConstrained'
+        headers['Authorization'] = f'Token {api_key}'
+        if version != 'v1alpha':
+          warnings.warn(
+              message=(
+                  "The SDK's ephemeral token support is in v1alpha only."
+                  'Please use client = genai.Client(api_key=token.name, '
+                  'http_options=types.HttpOptions(api_version="v1alpha"))'
+                  ' before session connection.'
+              ),
+              category=errors.ExperimentalWarning,
+          )
+      uri = f'{base_url}/ws/google.ai.generativelanguage.{version}.GenerativeService.{method}'
+
+      request_dict = _common.convert_to_dict(
+          live_converters._LiveConnectParameters_to_mldev(
+              api_client=self._api_client,
+              from_object=types.LiveConnectParameters(
+                  model=transformed_model,
+                  config=parameter_model,
+              ).model_dump(exclude_none=True),
+          )
       )
-    else:
-      parameter_model = config
+      del request_dict['config']
+
+      setv(request_dict, ['setup', 'model'], transformed_model)
 
-    if self._api_client.api_key:
+      request = json.dumps(request_dict)
+    elif self._api_client.api_key and self._api_client.vertexai:
+      # Headers already contains api key for express mode.
       api_key = self._api_client.api_key
-      version = self._api_client._http_options['api_version']
-      uri = f'{base_url}/ws/google.ai.generativelanguage.{version}.GenerativeService.BidiGenerateContent?key={api_key}'
-      headers = self._api_client._http_options['headers']
+      version = self._api_client._http_options.api_version
+      uri = f'{base_url}/ws/google.cloud.aiplatform.{version}.LlmBidiService/BidiGenerateContent'
+      original_headers = self._api_client._http_options.headers
+      headers = original_headers.copy() if original_headers is not None else {}
+
       request_dict = _common.convert_to_dict(
-          self._LiveSetup_to_mldev(
-              model=transformed_model,
-              config=parameter_model,
+          live_converters._LiveConnectParameters_to_vertex(
+              api_client=self._api_client,
+              from_object=types.LiveConnectParameters(
+                  model=transformed_model,
+                  config=parameter_model,
+              ).model_dump(exclude_none=True),
           )
       )
+      del request_dict['config']
+
+      setv(request_dict, ['setup', 'model'], transformed_model)
+
       request = json.dumps(request_dict)
     else:
-      # Get bearer token through Application Default Credentials.
-      creds, _ = google.auth.default(
-          scopes=['https://www.googleapis.com/auth/cloud-platform']
+      version = self._api_client._http_options.api_version
+      has_sufficient_auth = (
+          self._api_client.project and self._api_client.location
       )
+      if self._api_client.custom_base_url and not has_sufficient_auth:
+        # API gateway proxy can use the auth in custom headers, not url.
+        # Enable custom url if auth is not sufficient.
+        uri = self._api_client.custom_base_url
+        # Keep the model as is.
+        transformed_model = model
+        # Do not get credentials for custom url.
+        original_headers = self._api_client._http_options.headers
+        headers = (
+            original_headers.copy() if original_headers is not None else {}
+        )
+
+      else:
+        uri = f'{base_url}/ws/google.cloud.aiplatform.{version}.LlmBidiService/BidiGenerateContent'
+
+        if not self._api_client._credentials:
+          # Get bearer token through Application Default Credentials.
+          creds, _ = google.auth.default(  # type: ignore
+              scopes=['https://www.googleapis.com/auth/cloud-platform']
+          )
+        else:
+          creds = self._api_client._credentials
+        # creds.valid is False, and creds.token is None
+        # Need to refresh credentials to populate those
+        if not (creds.token and creds.valid):
+          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)
+        bearer_token = creds.token
+
+        original_headers = self._api_client._http_options.headers
+        headers = (
+            original_headers.copy() if original_headers is not None else {}
+        )
+        if not headers.get('Authorization'):
+          headers['Authorization'] = f'Bearer {bearer_token}'
 
-      # creds.valid is False, and creds.token is None
-      # Need to refresh credentials to populate those
-      auth_req = google.auth.transport.requests.Request()
-      creds.refresh(auth_req)
-      bearer_token = creds.token
-      headers = self._api_client._http_options['headers']
-      if headers is not None:
-        headers.update({
-            'Authorization': 'Bearer {}'.format(bearer_token),
-        })
-      version = self._api_client._http_options['api_version']
-      uri = f'{base_url}/ws/google.cloud.aiplatform.{version}.LlmBidiService/BidiGenerateContent'
       location = self._api_client.location
       project = self._api_client.project
-      if transformed_model.startswith('publishers/'):
+      if transformed_model.startswith('publishers/') and project and location:
         transformed_model = (
             f'projects/{project}/locations/{location}/' + transformed_model
         )
       request_dict = _common.convert_to_dict(
-          self._LiveSetup_to_vertex(
-              model=transformed_model,
-              config=parameter_model,
+          live_converters._LiveConnectParameters_to_vertex(
+              api_client=self._api_client,
+              from_object=types.LiveConnectParameters(
+                  model=transformed_model,
+                  config=parameter_model,
+              ).model_dump(exclude_none=True),
           )
       )
+      del request_dict['config']
+
+      if (
+          getv(
+              request_dict, ['setup', 'generationConfig', 'responseModalities']
+          )
+          is None
+      ):
+        setv(
+            request_dict,
+            ['setup', 'generationConfig', 'responseModalities'],
+            ['AUDIO'],
+        )
+
       request = json.dumps(request_dict)
 
-    async with connect(uri, additional_headers=headers) as ws:
+    if parameter_model.tools and _mcp_utils.has_mcp_tool_usage(
+        parameter_model.tools
+    ):
+      if headers is None:
+        headers = {}
+      _mcp_utils.set_mcp_usage_header(headers)
+
+    async with ws_connect(
+        uri, additional_headers=headers, **self._api_client._websocket_ssl_ctx
+    ) as ws:
       await ws.send(request)
-      logger.info(await ws.recv(decode=False))
+      try:
+        # websockets 14.0+
+        raw_response = await ws.recv(decode=False)
+      except TypeError:
+        raw_response = await ws.recv()  # type: ignore[assignment]
+      if raw_response:
+        try:
+          response = json.loads(raw_response)
+        except json.decoder.JSONDecodeError:
+          raise ValueError(f'Failed to parse response: {raw_response!r}')
+      else:
+        response = {}
+
+      if self._api_client.vertexai:
+        response_dict = live_converters._LiveServerMessage_from_vertex(response)
+      else:
+        response_dict = response
+
+      setup_response = types.LiveServerMessage._from_response(
+          response=response_dict, kwargs=parameter_model.model_dump()
+      )
+      if setup_response.setup_complete:
+        session_id = setup_response.setup_complete.session_id
+      else:
+        session_id = None
+      yield AsyncSession(
+          api_client=self._api_client,
+          websocket=ws,
+          session_id=session_id,
+      )
+
+
+async 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):
+    if getv(config, ['system_instruction']) is not None:
+      converted_system_instruction = t.t_content(
+          getv(config, ['system_instruction'])
+      )
+    else:
+      converted_system_instruction = None
+    parameter_model = types.LiveConnectConfig(**config)
+    parameter_model.system_instruction = converted_system_instruction
+  else:
+    if config.system_instruction is None:
+      system_instruction = None
+    else:
+      system_instruction = t.t_content(getv(config, ['system_instruction']))
+    parameter_model = config
+    parameter_model.system_instruction = system_instruction
+
+  # Create a copy of the config model with the tools field cleared as they will
+  # be replaced with the MCP tools converted to GenAI tools.
+  parameter_model_copy = parameter_model.model_copy(update={'tools': None})
+  if parameter_model.tools:
+    parameter_model_copy.tools = []
+    for tool in parameter_model.tools:
+      if McpClientSession is not None and isinstance(tool, McpClientSession):
+        mcp_to_genai_tool_adapter = McpToGenAiToolAdapter(
+            tool, await tool.list_tools()
+        )
+        # Extend the config with the MCP session tools converted to GenAI tools.
+        parameter_model_copy.tools.extend(mcp_to_genai_tool_adapter.tools)
+      elif McpTool is not None and isinstance(tool, McpTool):
+        parameter_model_copy.tools.append(mcp_to_gemini_tool(tool))
+      else:
+        parameter_model_copy.tools.append(tool)
+
+  if parameter_model_copy.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_copy