google-genai 1.8.0__tar.gz → 1.9.0__tar.gz

{google_genai-1.8.0/google_genai.egg-info → google_genai-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.8.0
+Version: 1.9.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/_transformers.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.
@@ -26,7 +26,7 @@ import sys
 import time
 import types as builtin_types
 import typing
-from typing import Any, GenericAlias, Optional, Union  # type: ignore[attr-defined]
+from typing import Any, GenericAlias, Optional, Sequence, Union  # type: ignore[attr-defined]
 
 if typing.TYPE_CHECKING:
   import PIL.Image
@@ -251,6 +251,62 @@ def pil_to_blob(img) -> types.Blob:
   return types.Blob(mime_type=mime_type, data=data)
 
 
+def t_function_response(
+    function_response: types.FunctionResponseOrDict,
+) -> types.FunctionResponse:
+  if not function_response:
+    raise ValueError('function_response is required.')
+  if isinstance(function_response, dict):
+    return types.FunctionResponse.model_validate(function_response)
+  elif isinstance(function_response, types.FunctionResponse):
+    return function_response
+  else:
+    raise TypeError(
+        f'Could not parse input as FunctionResponse. Unsupported'
+        f' function_response type: {type(function_response)}'
+    )
+
+def t_function_responses(
+    function_responses: Union[
+        types.FunctionResponseOrDict,
+        Sequence[types.FunctionResponseOrDict],
+    ],
+) -> list[types.FunctionResponse]:
+  if not function_responses:
+    raise ValueError('function_responses are required.')
+  if isinstance(function_responses, Sequence):
+    return [t_function_response(response) for response in function_responses]
+  else:
+    return [t_function_response(function_responses)]
+
+
+BlobUnion = Union[types.Blob, types.BlobDict, 'PIL.Image.Image']
+
+def t_blob(blob: BlobUnion) -> types.Blob:
+  try:
+    import PIL.Image
+
+    PIL_Image = PIL.Image.Image
+  except ImportError:
+    PIL_Image = None
+
+  if not blob:
+    raise ValueError('blob is required.')
+
+  if isinstance(blob, types.Blob):
+    return blob
+
+  if isinstance(blob, dict):
+    return types.Blob.model_validate(blob)
+
+  if PIL_Image is not None and isinstance(blob, PIL_Image):
+    return pil_to_blob(blob)
+
+  raise TypeError(
+      f'Could not parse input as Blob. Unsupported blob type: {type(blob)}'
+  )
+
+
 def t_part(part: Optional[types.PartUnionDict]) -> types.Part:
   try:
     import PIL.Image

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/batches.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.

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/caches.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.

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/errors.py

@@ -36,7 +36,7 @@ class APIError(Exception):
       self,
       code: int,
       response_json: Any,
-      response: Union['ReplayResponse', httpx.Response],
+      response: Optional[Union['ReplayResponse', httpx.Response]] = None,
   ):
     self.response = response
     self.details = response_json

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/files.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.

{google_genai-1.8.0 → google_genai-1.9.0}/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.
@@ -21,6 +21,7 @@ import contextlib
 import json
 import logging
 from typing import Any, AsyncIterator, Dict, Optional, Sequence, Union, 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,6 +65,59 @@ _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_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."""
 
@@ -112,6 +165,208 @@ class AsyncSession:
     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.
 
@@ -207,7 +462,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()
     if raw_response:
       try:
         response = json.loads(raw_response)
@@ -258,6 +516,12 @@ class AsyncSession:
       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']))
+    if getv(from_object, ['generationComplete']) is not None:
+      setv(
+          to_object,
+          ['generation_complete'],
+          getv(from_object, ['generationComplete']),
+      )
     return to_object
 
   def _LiveToolCall_from_mldev(
@@ -329,6 +593,25 @@ 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']),
+      )
+    # Vertex supports transcription.
+    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
@@ -669,6 +952,79 @@ 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."""
 
@@ -715,7 +1071,39 @@ 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, ['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,
@@ -796,6 +1184,39 @@ 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, ['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,6 +1240,24 @@ 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']),
+          ),
+      )
 
     return_value = {'setup': {'model': model}}
     return_value['setup'].update(to_object)
@@ -865,8 +1304,15 @@ class AsyncLive(_api_module.BaseModule):
           generation_config=config.get('generation_config'),
           response_modalities=config.get('response_modalities'),
           speech_config=config.get('speech_config'),
+          temperature=config.get('temperature'),
+          top_p=config.get('top_p'),
+          top_k=config.get('top_k'),
+          max_output_tokens=config.get('max_output_tokens'),
+          seed=config.get('seed'),
           system_instruction=system_instruction,
           tools=config.get('tools'),
+          input_audio_transcription=config.get('input_audio_transcription'),
+          output_audio_transcription=config.get('output_audio_transcription'),
       )
     else:
       parameter_model = config
@@ -915,8 +1361,16 @@ 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)
+        yield AsyncSession(api_client=self._api_client, websocket=ws)

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/models.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.

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/operations.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.

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/tunings.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.

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/types.py

@@ -708,7 +708,7 @@ class Content(_common.BaseModel):
       default=None,
       description="""Optional. The producer of the content. Must be either 'user' or
       'model'. Useful to set for multi-turn conversations, otherwise can be
-      left blank or unset. If role is not specified, SDK will determine the role.""",
+      empty. If role is not specified, SDK will determine the role.""",
   )
 
 
@@ -783,7 +783,7 @@ class ContentDict(TypedDict, total=False):
   role: Optional[str]
   """Optional. The producer of the content. Must be either 'user' or
       'model'. Useful to set for multi-turn conversations, otherwise can be
-      left blank or unset. If role is not specified, SDK will determine the role."""
+      empty. If role is not specified, SDK will determine the role."""
 
 
 ContentOrDict = Union[Content, ContentDict]
@@ -8774,6 +8774,36 @@ LiveServerSetupCompleteOrDict = Union[
 ]
 
 
+class Transcription(_common.BaseModel):
+  """Audio transcription in Server Conent."""
+
+  text: Optional[str] = Field(
+      default=None,
+      description="""Transcription text.
+      """,
+  )
+  finished: Optional[bool] = Field(
+      default=None,
+      description="""The bool indicates the end of the transcription.
+      """,
+  )
+
+
+class TranscriptionDict(TypedDict, total=False):
+  """Audio transcription in Server Conent."""
+
+  text: Optional[str]
+  """Transcription text.
+      """
+
+  finished: Optional[bool]
+  """The bool indicates the end of the transcription.
+      """
+
+
+TranscriptionOrDict = Union[Transcription, TranscriptionDict]
+
+
 class LiveServerContent(_common.BaseModel):
   """Incremental server update generated by the model in response to client messages.
 
@@ -8793,6 +8823,30 @@ class LiveServerContent(_common.BaseModel):
       default=None,
       description="""If true, indicates that a client message has interrupted current model generation. If the client is playing out the content in realtime, this is a good signal to stop and empty the current queue.""",
   )
+  generation_complete: Optional[bool] = Field(
+      default=None,
+      description="""If true, indicates that the model is done generating. When model is
+      interrupted while generating there will be no generation_complete message
+      in interrupted turn, it will go through interrupted > turn_complete.
+      When model assumes realtime playback there will be delay between
+      generation_complete and turn_complete that is caused by model
+      waiting for playback to finish. If true, indicates that the model
+      has finished generating all content. This is a signal to the client
+      that it can stop sending messages.""",
+  )
+  input_transcription: Optional[Transcription] = Field(
+      default=None,
+      description="""Input transcription. The transcription is independent to the model
+      turn which means it doesn’t imply any ordering between transcription and
+      model turn.""",
+  )
+  output_transcription: Optional[Transcription] = Field(
+      default=None,
+      description="""Output transcription. The transcription is independent to the model
+      turn which means it doesn’t imply any ordering between transcription and
+      model turn.
+      """,
+  )
 
 
 class LiveServerContentDict(TypedDict, total=False):
@@ -8811,6 +8865,27 @@ class LiveServerContentDict(TypedDict, total=False):
   interrupted: Optional[bool]
   """If true, indicates that a client message has interrupted current model generation. If the client is playing out the content in realtime, this is a good signal to stop and empty the current queue."""
 
+  generation_complete: Optional[bool]
+  """If true, indicates that the model is done generating. When model is
+      interrupted while generating there will be no generation_complete message
+      in interrupted turn, it will go through interrupted > turn_complete.
+      When model assumes realtime playback there will be delay between
+      generation_complete and turn_complete that is caused by model
+      waiting for playback to finish. If true, indicates that the model
+      has finished generating all content. This is a signal to the client
+      that it can stop sending messages."""
+
+  input_transcription: Optional[TranscriptionDict]
+  """Input transcription. The transcription is independent to the model
+      turn which means it doesn’t imply any ordering between transcription and
+      model turn."""
+
+  output_transcription: Optional[TranscriptionDict]
+  """Output transcription. The transcription is independent to the model
+      turn which means it doesn’t imply any ordering between transcription and
+      model turn.
+      """
+
 
 LiveServerContentOrDict = Union[LiveServerContent, LiveServerContentDict]
 
@@ -8950,15 +9025,7 @@ class LiveClientSetup(_common.BaseModel):
   generation_config: Optional[GenerationConfig] = Field(
       default=None,
       description="""The generation configuration for the session.
-
-The following fields are supported:
-- `response_logprobs`
-- `response_mime_type`
-- `logprobs`
-- `response_schema`
-- `stop_sequence`
-- `routing_config`
-- `audio_timestamp`
+      Note: only a subset of fields are supported.
       """,
   )
   system_instruction: Optional[Content] = Field(
@@ -8988,15 +9055,7 @@ class LiveClientSetupDict(TypedDict, total=False):
 
   generation_config: Optional[GenerationConfigDict]
   """The generation configuration for the session.
-
-The following fields are supported:
-- `response_logprobs`
-- `response_mime_type`
-- `logprobs`
-- `response_schema`
-- `stop_sequence`
-- `routing_config`
-- `audio_timestamp`
+      Note: only a subset of fields are supported.
       """
 
   system_instruction: Optional[ContentDict]
@@ -9070,11 +9129,11 @@ LiveClientContentOrDict = Union[LiveClientContent, LiveClientContentDict]
 class LiveClientRealtimeInput(_common.BaseModel):
   """User input that is sent in real time.
 
-  This is different from `ClientContentUpdate` in a few ways:
+  This is different from `LiveClientContent` in a few ways:
 
     - Can be sent continuously without interruption to model generation.
     - If there is a need to mix data interleaved across the
-      `ClientContentUpdate` and the `RealtimeUpdate`, server attempts to
+      `LiveClientContent` and the `LiveClientRealtimeInput`, server attempts to
       optimize for best response, but there are no guarantees.
     - End of turn is not explicitly specified, but is rather derived from user
       activity (for example, end of speech).
@@ -9092,11 +9151,11 @@ class LiveClientRealtimeInput(_common.BaseModel):
 class LiveClientRealtimeInputDict(TypedDict, total=False):
   """User input that is sent in real time.
 
-  This is different from `ClientContentUpdate` in a few ways:
+  This is different from `LiveClientContent` in a few ways:
 
     - Can be sent continuously without interruption to model generation.
     - If there is a need to mix data interleaved across the
-      `ClientContentUpdate` and the `RealtimeUpdate`, server attempts to
+      `LiveClientContent` and the `LiveClientRealtimeInput`, server attempts to
       optimize for best response, but there are no guarantees.
     - End of turn is not explicitly specified, but is rather derived from user
       activity (for example, end of speech).
@@ -9192,6 +9251,23 @@ class LiveClientMessageDict(TypedDict, total=False):
 LiveClientMessageOrDict = Union[LiveClientMessage, LiveClientMessageDict]
 
 
+class AudioTranscriptionConfig(_common.BaseModel):
+  """The audio transcription configuration in Setup."""
+
+  pass
+
+
+class AudioTranscriptionConfigDict(TypedDict, total=False):
+  """The audio transcription configuration in Setup."""
+
+  pass
+
+
+AudioTranscriptionConfigOrDict = Union[
+    AudioTranscriptionConfig, AudioTranscriptionConfigDict
+]
+
+
 class LiveConnectConfig(_common.BaseModel):
   """Session config for the API connection."""
 
@@ -9205,6 +9281,42 @@ class LiveConnectConfig(_common.BaseModel):
       modalities that the model can return. Defaults to AUDIO if not specified.
       """,
   )
+  temperature: Optional[float] = Field(
+      default=None,
+      description="""Value that controls the degree of randomness in token selection.
+      Lower temperatures are good for prompts that require a less open-ended or
+      creative response, while higher temperatures can lead to more diverse or
+      creative results.
+      """,
+  )
+  top_p: Optional[float] = Field(
+      default=None,
+      description="""Tokens are selected from the most to least probable until the sum
+      of their probabilities equals this value. Use a lower value for less
+      random responses and a higher value for more random responses.
+      """,
+  )
+  top_k: Optional[float] = Field(
+      default=None,
+      description="""For each token selection step, the ``top_k`` tokens with the
+      highest probabilities are sampled. Then tokens are further filtered based
+      on ``top_p`` with the final token selected using temperature sampling. Use
+      a lower number for less random responses and a higher number for more
+      random responses.
+      """,
+  )
+  max_output_tokens: Optional[int] = Field(
+      default=None,
+      description="""Maximum number of tokens that can be generated in the response.
+      """,
+  )
+  seed: Optional[int] = Field(
+      default=None,
+      description="""When ``seed`` is fixed to a specific number, the model makes a best
+      effort to provide the same response for repeated requests. By default, a
+      random number is used.
+      """,
+  )
   speech_config: Optional[SpeechConfig] = Field(
       default=None,
       description="""The speech generation configuration.
@@ -9224,6 +9336,17 @@ class LiveConnectConfig(_common.BaseModel):
       external systems to perform an action, or set of actions, outside of
       knowledge and scope of the model.""",
   )
+  input_audio_transcription: Optional[AudioTranscriptionConfig] = Field(
+      default=None,
+      description="""The transcription of the input aligns with the input audio language.
+      """,
+  )
+  output_audio_transcription: Optional[AudioTranscriptionConfig] = Field(
+      default=None,
+      description="""The transcription of the output aligns with the language code
+      specified for the output audio.
+      """,
+  )
 
 
 class LiveConnectConfigDict(TypedDict, total=False):
@@ -9237,6 +9360,37 @@ class LiveConnectConfigDict(TypedDict, total=False):
       modalities that the model can return. Defaults to AUDIO if not specified.
       """
 
+  temperature: Optional[float]
+  """Value that controls the degree of randomness in token selection.
+      Lower temperatures are good for prompts that require a less open-ended or
+      creative response, while higher temperatures can lead to more diverse or
+      creative results.
+      """
+
+  top_p: Optional[float]
+  """Tokens are selected from the most to least probable until the sum
+      of their probabilities equals this value. Use a lower value for less
+      random responses and a higher value for more random responses.
+      """
+
+  top_k: Optional[float]
+  """For each token selection step, the ``top_k`` tokens with the
+      highest probabilities are sampled. Then tokens are further filtered based
+      on ``top_p`` with the final token selected using temperature sampling. Use
+      a lower number for less random responses and a higher number for more
+      random responses.
+      """
+
+  max_output_tokens: Optional[int]
+  """Maximum number of tokens that can be generated in the response.
+      """
+
+  seed: Optional[int]
+  """When ``seed`` is fixed to a specific number, the model makes a best
+      effort to provide the same response for repeated requests. By default, a
+      random number is used.
+      """
+
   speech_config: Optional[SpeechConfigDict]
   """The speech generation configuration.
       """
@@ -9253,5 +9407,14 @@ class LiveConnectConfigDict(TypedDict, total=False):
       external systems to perform an action, or set of actions, outside of
       knowledge and scope of the model."""
 
+  input_audio_transcription: Optional[AudioTranscriptionConfigDict]
+  """The transcription of the input aligns with the input audio language.
+      """
+
+  output_audio_transcription: Optional[AudioTranscriptionConfigDict]
+  """The transcription of the output aligns with the language code
+      specified for the output audio.
+      """
+
 
 LiveConnectConfigOrDict = Union[LiveConnectConfig, LiveConnectConfigDict]

{google_genai-1.8.0 → google_genai-1.9.0}/google/genai/version.py

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

{google_genai-1.8.0 → google_genai-1.9.0/google_genai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.8.0
+Version: 1.9.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0

{google_genai-1.8.0 → google_genai-1.9.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "google-genai"
-version = "1.8.0"
+version = "1.9.0"
 description = "GenAI Python SDK"
 readme = "README.md"
 license = {text = "Apache-2.0"}