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

google/genai/types.py

@@ -128,14 +128,6 @@ class Mode(_common.CaseInSensitiveEnum):
   MODE_DYNAMIC = 'MODE_DYNAMIC'
 
 
-class State(_common.CaseInSensitiveEnum):
-  """Output only. RagFile state."""
-
-  STATE_UNSPECIFIED = 'STATE_UNSPECIFIED'
-  ACTIVE = 'ACTIVE'
-  ERROR = 'ERROR'
-
-
 class FinishReason(_common.CaseInSensitiveEnum):
   """Output only. The reason why the model stopped generating tokens.
 
@@ -185,6 +177,18 @@ class BlockedReason(_common.CaseInSensitiveEnum):
   PROHIBITED_CONTENT = 'PROHIBITED_CONTENT'
 
 
+class TrafficType(_common.CaseInSensitiveEnum):
+  """Output only.
+
+  Traffic type. This shows whether a request consumes Pay-As-You-Go or
+  Provisioned Throughput quota.
+  """
+
+  TRAFFIC_TYPE_UNSPECIFIED = 'TRAFFIC_TYPE_UNSPECIFIED'
+  ON_DEMAND = 'ON_DEMAND'
+  PROVISIONED_THROUGHPUT = 'PROVISIONED_THROUGHPUT'
+
+
 class Modality(_common.CaseInSensitiveEnum):
   """Server content modalities."""
 
@@ -194,15 +198,13 @@ class Modality(_common.CaseInSensitiveEnum):
   AUDIO = 'AUDIO'
 
 
-class DeploymentResourcesType(_common.CaseInSensitiveEnum):
-  """"""
+class MediaResolution(_common.CaseInSensitiveEnum):
+  """The media resolution to use."""
 
-  DEPLOYMENT_RESOURCES_TYPE_UNSPECIFIED = (
-      'DEPLOYMENT_RESOURCES_TYPE_UNSPECIFIED'
-  )
-  DEDICATED_RESOURCES = 'DEDICATED_RESOURCES'
-  AUTOMATIC_RESOURCES = 'AUTOMATIC_RESOURCES'
-  SHARED_RESOURCES = 'SHARED_RESOURCES'
+  MEDIA_RESOLUTION_UNSPECIFIED = 'MEDIA_RESOLUTION_UNSPECIFIED'
+  MEDIA_RESOLUTION_LOW = 'MEDIA_RESOLUTION_LOW'
+  MEDIA_RESOLUTION_MEDIUM = 'MEDIA_RESOLUTION_MEDIUM'
+  MEDIA_RESOLUTION_HIGH = 'MEDIA_RESOLUTION_HIGH'
 
 
 class JobState(_common.CaseInSensitiveEnum):
@@ -227,6 +229,7 @@ class AdapterSize(_common.CaseInSensitiveEnum):
 
   ADAPTER_SIZE_UNSPECIFIED = 'ADAPTER_SIZE_UNSPECIFIED'
   ADAPTER_SIZE_ONE = 'ADAPTER_SIZE_ONE'
+  ADAPTER_SIZE_TWO = 'ADAPTER_SIZE_TWO'
   ADAPTER_SIZE_FOUR = 'ADAPTER_SIZE_FOUR'
   ADAPTER_SIZE_EIGHT = 'ADAPTER_SIZE_EIGHT'
   ADAPTER_SIZE_SIXTEEN = 'ADAPTER_SIZE_SIXTEEN'
@@ -249,15 +252,6 @@ class FunctionCallingConfigMode(_common.CaseInSensitiveEnum):
   NONE = 'NONE'
 
 
-class MediaResolution(_common.CaseInSensitiveEnum):
-  """The media resolution to use."""
-
-  MEDIA_RESOLUTION_UNSPECIFIED = 'MEDIA_RESOLUTION_UNSPECIFIED'
-  MEDIA_RESOLUTION_LOW = 'MEDIA_RESOLUTION_LOW'
-  MEDIA_RESOLUTION_MEDIUM = 'MEDIA_RESOLUTION_MEDIUM'
-  MEDIA_RESOLUTION_HIGH = 'MEDIA_RESOLUTION_HIGH'
-
-
 class SafetyFilterLevel(_common.CaseInSensitiveEnum):
   """Enum that controls the safety filter level for objectionable content."""
 
@@ -354,6 +348,38 @@ class MediaModality(_common.CaseInSensitiveEnum):
   DOCUMENT = 'DOCUMENT'
 
 
+class StartSensitivity(_common.CaseInSensitiveEnum):
+  """Start of speech sensitivity."""
+
+  START_SENSITIVITY_UNSPECIFIED = 'START_SENSITIVITY_UNSPECIFIED'
+  START_SENSITIVITY_HIGH = 'START_SENSITIVITY_HIGH'
+  START_SENSITIVITY_LOW = 'START_SENSITIVITY_LOW'
+
+
+class EndSensitivity(_common.CaseInSensitiveEnum):
+  """End of speech sensitivity."""
+
+  END_SENSITIVITY_UNSPECIFIED = 'END_SENSITIVITY_UNSPECIFIED'
+  END_SENSITIVITY_HIGH = 'END_SENSITIVITY_HIGH'
+  END_SENSITIVITY_LOW = 'END_SENSITIVITY_LOW'
+
+
+class ActivityHandling(_common.CaseInSensitiveEnum):
+  """The different ways of handling user activity."""
+
+  ACTIVITY_HANDLING_UNSPECIFIED = 'ACTIVITY_HANDLING_UNSPECIFIED'
+  START_OF_ACTIVITY_INTERRUPTS = 'START_OF_ACTIVITY_INTERRUPTS'
+  NO_INTERRUPTION = 'NO_INTERRUPTION'
+
+
+class TurnCoverage(_common.CaseInSensitiveEnum):
+  """Options about which input is included in the user's turn."""
+
+  TURN_COVERAGE_UNSPECIFIED = 'TURN_COVERAGE_UNSPECIFIED'
+  TURN_INCLUDES_ONLY_ACTIVITY = 'TURN_INCLUDES_ONLY_ACTIVITY'
+  TURN_INCLUDES_ALL_INPUT = 'TURN_INCLUDES_ALL_INPUT'
+
+
 class VideoMetadata(_common.BaseModel):
   """Metadata describes the input video content."""
 
@@ -632,18 +658,6 @@ class Part(_common.BaseModel):
     function_response = FunctionResponse(name=name, response=response)
     return cls(function_response=function_response)
 
-  @classmethod
-  def from_video_metadata(cls, *, start_offset: str, end_offset: str) -> 'Part':
-    logger.warning("""Part.from_video_metadata will be deprecated soon.
-           Because a Part instance needs to include at least one of the fields:
-           text, file_data, inline_data, function_call, function_response, executable_code or code_execution_result.
-           A Part instance contains only video_metadata is not a valid Part.
-        """)
-    video_metadata = VideoMetadata(
-        end_offset=end_offset, start_offset=start_offset
-    )
-    return cls(video_metadata=video_metadata)
-
   @classmethod
   def from_executable_code(cls, *, code: str, language: Language) -> 'Part':
     executable_code = ExecutableCode(code=code, language=language)
@@ -708,7 +722,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 +797,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]
@@ -1433,6 +1447,11 @@ ToolOrDict = Union[Tool, ToolDict]
 ToolListUnion = list[Union[Tool, Callable]]
 ToolListUnionDict = list[Union[ToolDict, Callable]]
 
+SchemaUnion = Union[
+    dict, type, Schema, builtin_types.GenericAlias, VersionedUnionType  # type: ignore[valid-type]
+]
+SchemaUnionDict = Union[SchemaUnion, SchemaDict]
+
 
 class FunctionCallingConfig(_common.BaseModel):
   """Function calling config."""
@@ -1615,6 +1634,11 @@ class ThinkingConfig(_common.BaseModel):
       description="""Indicates whether to include thoughts in the response. If true, thoughts are returned only if the model supports thought and thoughts are available.
       """,
   )
+  thinking_budget: Optional[int] = Field(
+      default=None,
+      description="""Indicates the thinking budget in tokens.
+      """,
+  )
 
 
 class ThinkingConfigDict(TypedDict, total=False):
@@ -1624,6 +1648,10 @@ class ThinkingConfigDict(TypedDict, total=False):
   """Indicates whether to include thoughts in the response. If true, thoughts are returned only if the model supports thought and thoughts are available.
       """
 
+  thinking_budget: Optional[int]
+  """Indicates the thinking budget in tokens.
+      """
+
 
 ThinkingConfigOrDict = Union[ThinkingConfig, ThinkingConfigDict]
 
@@ -1778,14 +1806,6 @@ ContentUnion = Union[Content, list[PartUnion], PartUnion]
 ContentUnionDict = Union[ContentUnion, ContentDict]
 
 
-SchemaUnion = Union[
-    dict, type, Schema, builtin_types.GenericAlias, VersionedUnionType
-]
-
-
-SchemaUnionDict = Union[SchemaUnion, SchemaDict]
-
-
 class GenerationConfigRoutingConfigAutoRoutingMode(_common.BaseModel):
   """When automated routing is specified, the routing will be determined by the pretrained routing model and customer provided model routing preference."""
 
@@ -2397,6 +2417,9 @@ GroundingChunkRetrievedContextOrDict = Union[
 class GroundingChunkWeb(_common.BaseModel):
   """Chunk from the web."""
 
+  domain: Optional[str] = Field(
+      default=None, description="""Domain of the (original) URI."""
+  )
   title: Optional[str] = Field(
       default=None, description="""Title of the chunk."""
   )
@@ -2408,6 +2431,9 @@ class GroundingChunkWeb(_common.BaseModel):
 class GroundingChunkWebDict(TypedDict, total=False):
   """Chunk from the web."""
 
+  domain: Optional[str]
+  """Domain of the (original) URI."""
+
   title: Optional[str]
   """Title of the chunk."""
 
@@ -2936,6 +2962,10 @@ class GenerateContentResponseUsageMetadata(_common.BaseModel):
       default=None,
       description="""Total token count for prompt, response candidates, and tool-use prompts (if present).""",
   )
+  traffic_type: Optional[TrafficType] = Field(
+      default=None,
+      description="""Output only. Traffic type. This shows whether a request consumes Pay-As-You-Go or Provisioned Throughput quota.""",
+  )
 
 
 class GenerateContentResponseUsageMetadataDict(TypedDict, total=False):
@@ -2971,6 +3001,9 @@ class GenerateContentResponseUsageMetadataDict(TypedDict, total=False):
   total_token_count: Optional[int]
   """Total token count for prompt, response candidates, and tool-use prompts (if present)."""
 
+  traffic_type: Optional[TrafficType]
+  """Output only. Traffic type. This shows whether a request consumes Pay-As-You-Go or Provisioned Throughput quota."""
+
 
 GenerateContentResponseUsageMetadataOrDict = Union[
     GenerateContentResponseUsageMetadata,
@@ -4878,6 +4911,10 @@ class GenerationConfig(_common.BaseModel):
       default=None,
       description="""Optional. The maximum number of output tokens to generate per message.""",
   )
+  media_resolution: Optional[MediaResolution] = Field(
+      default=None,
+      description="""Optional. If specified, the media resolution specified will be used.""",
+  )
   presence_penalty: Optional[float] = Field(
       default=None, description="""Optional. Positive penalties."""
   )
@@ -4932,6 +4969,9 @@ class GenerationConfigDict(TypedDict, total=False):
   max_output_tokens: Optional[int]
   """Optional. The maximum number of output tokens to generate per message."""
 
+  media_resolution: Optional[MediaResolution]
+  """Optional. If specified, the media resolution specified will be used."""
+
   presence_penalty: Optional[float]
   """Optional. Positive penalties."""
 
@@ -5471,9 +5511,8 @@ class GenerateVideosOperation(_common.BaseModel):
       default=None,
       description="""The error result of the operation in case of failure or cancellation.""",
   )
-  response: Optional[dict[str, Any]] = Field(
-      default=None,
-      description="""The normal response of the operation in case of success.""",
+  response: Optional[GenerateVideosResponse] = Field(
+      default=None, description="""The generated videos."""
   )
   result: Optional[GenerateVideosResponse] = Field(
       default=None, description="""The generated videos."""
@@ -5495,8 +5534,8 @@ class GenerateVideosOperationDict(TypedDict, total=False):
   error: Optional[dict[str, Any]]
   """The error result of the operation in case of failure or cancellation."""
 
-  response: Optional[dict[str, Any]]
-  """The normal response of the operation in case of success."""
+  response: Optional[GenerateVideosResponseDict]
+  """The generated videos."""
 
   result: Optional[GenerateVideosResponseDict]
   """The generated videos."""
@@ -6693,10 +6732,6 @@ class Operation(_common.BaseModel):
       default=None,
       description="""The error result of the operation in case of failure or cancellation.""",
   )
-  response: Optional[dict[str, Any]] = Field(
-      default=None,
-      description="""The normal response of the operation in case of success.""",
-  )
 
 
 class OperationDict(TypedDict, total=False):
@@ -6714,9 +6749,6 @@ class OperationDict(TypedDict, total=False):
   error: Optional[dict[str, Any]]
   """The error result of the operation in case of failure or cancellation."""
 
-  response: Optional[dict[str, Any]]
-  """The normal response of the operation in case of success."""
-
 
 OperationOrDict = Union[Operation, OperationDict]
 
@@ -8774,6 +8806,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 +8855,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 +8897,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]
 
@@ -8863,6 +8970,165 @@ LiveServerToolCallCancellationOrDict = Union[
 ]
 
 
+class UsageMetadata(_common.BaseModel):
+  """Usage metadata about response(s)."""
+
+  prompt_token_count: Optional[int] = Field(
+      default=None,
+      description="""Number of tokens in the prompt. When `cached_content` is set, this is still the total effective prompt size meaning this includes the number of tokens in the cached content.""",
+  )
+  cached_content_token_count: Optional[int] = Field(
+      default=None,
+      description="""Number of tokens in the cached part of the prompt (the cached content).""",
+  )
+  response_token_count: Optional[int] = Field(
+      default=None,
+      description="""Total number of tokens across all the generated response candidates.""",
+  )
+  tool_use_prompt_token_count: Optional[int] = Field(
+      default=None,
+      description="""Number of tokens present in tool-use prompt(s).""",
+  )
+  thoughts_token_count: Optional[int] = Field(
+      default=None,
+      description="""Number of tokens of thoughts for thinking models.""",
+  )
+  total_token_count: Optional[int] = Field(
+      default=None,
+      description="""Total token count for prompt, response candidates, and tool-use prompts(if present).""",
+  )
+  prompt_tokens_details: Optional[list[ModalityTokenCount]] = Field(
+      default=None,
+      description="""List of modalities that were processed in the request input.""",
+  )
+  cache_tokens_details: Optional[list[ModalityTokenCount]] = Field(
+      default=None,
+      description="""List of modalities that were processed in the cache input.""",
+  )
+  response_tokens_details: Optional[list[ModalityTokenCount]] = Field(
+      default=None,
+      description="""List of modalities that were returned in the response.""",
+  )
+  tool_use_prompt_tokens_details: Optional[list[ModalityTokenCount]] = Field(
+      default=None,
+      description="""List of modalities that were processed in the tool-use prompt.""",
+  )
+  traffic_type: Optional[TrafficType] = Field(
+      default=None,
+      description="""Traffic type. This shows whether a request consumes Pay-As-You-Go
+ or Provisioned Throughput quota.""",
+  )
+
+
+class UsageMetadataDict(TypedDict, total=False):
+  """Usage metadata about response(s)."""
+
+  prompt_token_count: Optional[int]
+  """Number of tokens in the prompt. When `cached_content` is set, this is still the total effective prompt size meaning this includes the number of tokens in the cached content."""
+
+  cached_content_token_count: Optional[int]
+  """Number of tokens in the cached part of the prompt (the cached content)."""
+
+  response_token_count: Optional[int]
+  """Total number of tokens across all the generated response candidates."""
+
+  tool_use_prompt_token_count: Optional[int]
+  """Number of tokens present in tool-use prompt(s)."""
+
+  thoughts_token_count: Optional[int]
+  """Number of tokens of thoughts for thinking models."""
+
+  total_token_count: Optional[int]
+  """Total token count for prompt, response candidates, and tool-use prompts(if present)."""
+
+  prompt_tokens_details: Optional[list[ModalityTokenCountDict]]
+  """List of modalities that were processed in the request input."""
+
+  cache_tokens_details: Optional[list[ModalityTokenCountDict]]
+  """List of modalities that were processed in the cache input."""
+
+  response_tokens_details: Optional[list[ModalityTokenCountDict]]
+  """List of modalities that were returned in the response."""
+
+  tool_use_prompt_tokens_details: Optional[list[ModalityTokenCountDict]]
+  """List of modalities that were processed in the tool-use prompt."""
+
+  traffic_type: Optional[TrafficType]
+  """Traffic type. This shows whether a request consumes Pay-As-You-Go
+ or Provisioned Throughput quota."""
+
+
+UsageMetadataOrDict = Union[UsageMetadata, UsageMetadataDict]
+
+
+class LiveServerGoAway(_common.BaseModel):
+  """Server will not be able to service client soon."""
+
+  time_left: Optional[str] = Field(
+      default=None,
+      description="""The remaining time before the connection will be terminated as ABORTED. The minimal time returned here is specified differently together with the rate limits for a given model.""",
+  )
+
+
+class LiveServerGoAwayDict(TypedDict, total=False):
+  """Server will not be able to service client soon."""
+
+  time_left: Optional[str]
+  """The remaining time before the connection will be terminated as ABORTED. The minimal time returned here is specified differently together with the rate limits for a given model."""
+
+
+LiveServerGoAwayOrDict = Union[LiveServerGoAway, LiveServerGoAwayDict]
+
+
+class LiveServerSessionResumptionUpdate(_common.BaseModel):
+  """Update of the session resumption state.
+
+  Only sent if `session_resumption` was set in the connection config.
+  """
+
+  new_handle: Optional[str] = Field(
+      default=None,
+      description="""New handle that represents state that can be resumed. Empty if `resumable`=false.""",
+  )
+  resumable: Optional[bool] = Field(
+      default=None,
+      description="""True if session can be resumed at this point. It might be not possible to resume session at some points. In that case we send update empty new_handle and resumable=false. Example of such case could be model executing function calls or just generating. Resuming session (using previous session token) in such state will result in some data loss.""",
+  )
+  last_consumed_client_message_index: Optional[int] = Field(
+      default=None,
+      description="""Index of last message sent by client that is included in state represented by this SessionResumptionToken. Only sent when `SessionResumptionConfig.transparent` is set.
+
+Presence of this index allows users to transparently reconnect and avoid issue of losing some part of realtime audio input/video. If client wishes to temporarily disconnect (for example as result of receiving GoAway) they can do it without losing state by buffering messages sent since last `SessionResmumptionTokenUpdate`. This field will enable them to limit buffering (avoid keeping all requests in RAM).
+
+Note: This should not be used for when resuming a session at some time later -- in those cases partial audio and video frames arelikely not needed.""",
+  )
+
+
+class LiveServerSessionResumptionUpdateDict(TypedDict, total=False):
+  """Update of the session resumption state.
+
+  Only sent if `session_resumption` was set in the connection config.
+  """
+
+  new_handle: Optional[str]
+  """New handle that represents state that can be resumed. Empty if `resumable`=false."""
+
+  resumable: Optional[bool]
+  """True if session can be resumed at this point. It might be not possible to resume session at some points. In that case we send update empty new_handle and resumable=false. Example of such case could be model executing function calls or just generating. Resuming session (using previous session token) in such state will result in some data loss."""
+
+  last_consumed_client_message_index: Optional[int]
+  """Index of last message sent by client that is included in state represented by this SessionResumptionToken. Only sent when `SessionResumptionConfig.transparent` is set.
+
+Presence of this index allows users to transparently reconnect and avoid issue of losing some part of realtime audio input/video. If client wishes to temporarily disconnect (for example as result of receiving GoAway) they can do it without losing state by buffering messages sent since last `SessionResmumptionTokenUpdate`. This field will enable them to limit buffering (avoid keeping all requests in RAM).
+
+Note: This should not be used for when resuming a session at some time later -- in those cases partial audio and video frames arelikely not needed."""
+
+
+LiveServerSessionResumptionUpdateOrDict = Union[
+    LiveServerSessionResumptionUpdate, LiveServerSessionResumptionUpdateDict
+]
+
+
 class LiveServerMessage(_common.BaseModel):
   """Response message for API call."""
 
@@ -8882,6 +9148,18 @@ class LiveServerMessage(_common.BaseModel):
       default=None,
       description="""Notification for the client that a previously issued `ToolCallMessage` with the specified `id`s should have been not executed and should be cancelled.""",
   )
+  usage_metadata: Optional[UsageMetadata] = Field(
+      default=None, description="""Usage metadata about model response(s)."""
+  )
+  go_away: Optional[LiveServerGoAway] = Field(
+      default=None, description="""Server will disconnect soon."""
+  )
+  session_resumption_update: Optional[LiveServerSessionResumptionUpdate] = (
+      Field(
+          default=None,
+          description="""Update of the session resumption state.""",
+      )
+  )
 
   @property
   def text(self) -> Optional[str]:
@@ -8933,10 +9211,206 @@ class LiveServerMessageDict(TypedDict, total=False):
   tool_call_cancellation: Optional[LiveServerToolCallCancellationDict]
   """Notification for the client that a previously issued `ToolCallMessage` with the specified `id`s should have been not executed and should be cancelled."""
 
+  usage_metadata: Optional[UsageMetadataDict]
+  """Usage metadata about model response(s)."""
+
+  go_away: Optional[LiveServerGoAwayDict]
+  """Server will disconnect soon."""
+
+  session_resumption_update: Optional[LiveServerSessionResumptionUpdateDict]
+  """Update of the session resumption state."""
+
 
 LiveServerMessageOrDict = Union[LiveServerMessage, LiveServerMessageDict]
 
 
+class AutomaticActivityDetection(_common.BaseModel):
+  """Configures automatic detection of activity."""
+
+  disabled: Optional[bool] = Field(
+      default=None,
+      description="""If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals.""",
+  )
+  start_of_speech_sensitivity: Optional[StartSensitivity] = Field(
+      default=None,
+      description="""Determines how likely speech is to be detected.""",
+  )
+  end_of_speech_sensitivity: Optional[EndSensitivity] = Field(
+      default=None,
+      description="""Determines how likely detected speech is ended.""",
+  )
+  prefix_padding_ms: Optional[int] = Field(
+      default=None,
+      description="""The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives.""",
+  )
+  silence_duration_ms: Optional[int] = Field(
+      default=None,
+      description="""The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency.""",
+  )
+
+
+class AutomaticActivityDetectionDict(TypedDict, total=False):
+  """Configures automatic detection of activity."""
+
+  disabled: Optional[bool]
+  """If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals."""
+
+  start_of_speech_sensitivity: Optional[StartSensitivity]
+  """Determines how likely speech is to be detected."""
+
+  end_of_speech_sensitivity: Optional[EndSensitivity]
+  """Determines how likely detected speech is ended."""
+
+  prefix_padding_ms: Optional[int]
+  """The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives."""
+
+  silence_duration_ms: Optional[int]
+  """The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency."""
+
+
+AutomaticActivityDetectionOrDict = Union[
+    AutomaticActivityDetection, AutomaticActivityDetectionDict
+]
+
+
+class RealtimeInputConfig(_common.BaseModel):
+  """Marks the end of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  automatic_activity_detection: Optional[AutomaticActivityDetection] = Field(
+      default=None,
+      description="""If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals.""",
+  )
+  activity_handling: Optional[ActivityHandling] = Field(
+      default=None, description="""Defines what effect activity has."""
+  )
+  turn_coverage: Optional[TurnCoverage] = Field(
+      default=None,
+      description="""Defines which input is included in the user's turn.""",
+  )
+
+
+class RealtimeInputConfigDict(TypedDict, total=False):
+  """Marks the end of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  automatic_activity_detection: Optional[AutomaticActivityDetectionDict]
+  """If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals."""
+
+  activity_handling: Optional[ActivityHandling]
+  """Defines what effect activity has."""
+
+  turn_coverage: Optional[TurnCoverage]
+  """Defines which input is included in the user's turn."""
+
+
+RealtimeInputConfigOrDict = Union[RealtimeInputConfig, RealtimeInputConfigDict]
+
+
+class SessionResumptionConfig(_common.BaseModel):
+  """Configuration of session resumption mechanism.
+
+  Included in `LiveConnectConfig.session_resumption`. If included server
+  will send `LiveServerSessionResumptionUpdate` messages.
+  """
+
+  handle: Optional[str] = Field(
+      default=None,
+      description="""Session resumption handle of previous session (session to restore).
+
+If not present new session will be started.""",
+  )
+  transparent: Optional[bool] = Field(
+      default=None,
+      description="""If set the server will send `last_consumed_client_message_index` in the `session_resumption_update` messages to allow for transparent reconnections.""",
+  )
+
+
+class SessionResumptionConfigDict(TypedDict, total=False):
+  """Configuration of session resumption mechanism.
+
+  Included in `LiveConnectConfig.session_resumption`. If included server
+  will send `LiveServerSessionResumptionUpdate` messages.
+  """
+
+  handle: Optional[str]
+  """Session resumption handle of previous session (session to restore).
+
+If not present new session will be started."""
+
+  transparent: Optional[bool]
+  """If set the server will send `last_consumed_client_message_index` in the `session_resumption_update` messages to allow for transparent reconnections."""
+
+
+SessionResumptionConfigOrDict = Union[
+    SessionResumptionConfig, SessionResumptionConfigDict
+]
+
+
+class SlidingWindow(_common.BaseModel):
+  """Context window will be truncated by keeping only suffix of it.
+
+  Context window will always be cut at start of USER role turn. System
+  instructions and `BidiGenerateContentSetup.prefix_turns` will not be
+  subject to the sliding window mechanism, they will always stay at the
+  beginning of context window.
+  """
+
+  target_tokens: Optional[int] = Field(
+      default=None,
+      description="""Session reduction target -- how many tokens we should keep. Window shortening operation has some latency costs, so we should avoid running it on every turn. Should be < trigger_tokens. If not set, trigger_tokens/2 is assumed.""",
+  )
+
+
+class SlidingWindowDict(TypedDict, total=False):
+  """Context window will be truncated by keeping only suffix of it.
+
+  Context window will always be cut at start of USER role turn. System
+  instructions and `BidiGenerateContentSetup.prefix_turns` will not be
+  subject to the sliding window mechanism, they will always stay at the
+  beginning of context window.
+  """
+
+  target_tokens: Optional[int]
+  """Session reduction target -- how many tokens we should keep. Window shortening operation has some latency costs, so we should avoid running it on every turn. Should be < trigger_tokens. If not set, trigger_tokens/2 is assumed."""
+
+
+SlidingWindowOrDict = Union[SlidingWindow, SlidingWindowDict]
+
+
+class ContextWindowCompressionConfig(_common.BaseModel):
+  """Enables context window compression -- mechanism managing model context window so it does not exceed given length."""
+
+  trigger_tokens: Optional[int] = Field(
+      default=None,
+      description="""Number of tokens (before running turn) that triggers context window compression mechanism.""",
+  )
+  sliding_window: Optional[SlidingWindow] = Field(
+      default=None, description="""Sliding window compression mechanism."""
+  )
+
+
+class ContextWindowCompressionConfigDict(TypedDict, total=False):
+  """Enables context window compression -- mechanism managing model context window so it does not exceed given length."""
+
+  trigger_tokens: Optional[int]
+  """Number of tokens (before running turn) that triggers context window compression mechanism."""
+
+  sliding_window: Optional[SlidingWindowDict]
+  """Sliding window compression mechanism."""
+
+
+ContextWindowCompressionConfigOrDict = Union[
+    ContextWindowCompressionConfig, ContextWindowCompressionConfigDict
+]
+
+
 class LiveClientSetup(_common.BaseModel):
   """Message contains configuration that will apply for the duration of the streaming session."""
 
@@ -8950,15 +9424,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(
@@ -8975,6 +9441,18 @@ The following fields are supported:
       external systems to perform an action, or set of actions, outside of
       knowledge and scope of the model.""",
   )
+  session_resumption: Optional[SessionResumptionConfig] = Field(
+      default=None,
+      description="""Configures session resumption mechanism.
+
+          If included server will send SessionResumptionUpdate messages.""",
+  )
+  context_window_compression: Optional[ContextWindowCompressionConfig] = Field(
+      default=None,
+      description="""Configures context window compression mechanism.
+
+      If included, server will compress context window to fit into given length.""",
+  )
 
 
 class LiveClientSetupDict(TypedDict, total=False):
@@ -8988,15 +9466,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]
@@ -9011,6 +9481,16 @@ The following fields are supported:
       external systems to perform an action, or set of actions, outside of
       knowledge and scope of the model."""
 
+  session_resumption: Optional[SessionResumptionConfigDict]
+  """Configures session resumption mechanism.
+
+          If included server will send SessionResumptionUpdate messages."""
+
+  context_window_compression: Optional[ContextWindowCompressionConfigDict]
+  """Configures context window compression mechanism.
+
+      If included, server will compress context window to fit into given length."""
+
 
 LiveClientSetupOrDict = Union[LiveClientSetup, LiveClientSetupDict]
 
@@ -9067,14 +9547,60 @@ class LiveClientContentDict(TypedDict, total=False):
 LiveClientContentOrDict = Union[LiveClientContent, LiveClientContentDict]
 
 
+class ActivityStart(_common.BaseModel):
+  """Marks the start of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  pass
+
+
+class ActivityStartDict(TypedDict, total=False):
+  """Marks the start of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  pass
+
+
+ActivityStartOrDict = Union[ActivityStart, ActivityStartDict]
+
+
+class ActivityEnd(_common.BaseModel):
+  """Marks the end of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  pass
+
+
+class ActivityEndDict(TypedDict, total=False):
+  """Marks the end of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  pass
+
+
+ActivityEndOrDict = Union[ActivityEnd, ActivityEndDict]
+
+
 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 +9618,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 +9718,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 +9748,47 @@ 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.
+      """,
+  )
+  media_resolution: Optional[MediaResolution] = Field(
+      default=None,
+      description="""If specified, the media resolution specified will be used.
+      """,
+  )
+  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 +9808,29 @@ class LiveConnectConfig(_common.BaseModel):
       external systems to perform an action, or set of actions, outside of
       knowledge and scope of the model.""",
   )
+  session_resumption: Optional[SessionResumptionConfig] = Field(
+      default=None,
+      description="""Configures session resumption mechanism.
+
+If included the server will send SessionResumptionUpdate messages.""",
+  )
+  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.
+      """,
+  )
+  context_window_compression: Optional[ContextWindowCompressionConfig] = Field(
+      default=None,
+      description="""Configures context window compression mechanism.
+
+      If included, server will compress context window to fit into given length.""",
+  )
 
 
 class LiveConnectConfigDict(TypedDict, total=False):
@@ -9237,6 +9844,41 @@ 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.
+      """
+
+  media_resolution: Optional[MediaResolution]
+  """If specified, the media resolution specified will be used.
+      """
+
+  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 +9895,24 @@ class LiveConnectConfigDict(TypedDict, total=False):
       external systems to perform an action, or set of actions, outside of
       knowledge and scope of the model."""
 
+  session_resumption: Optional[SessionResumptionConfigDict]
+  """Configures session resumption mechanism.
+
+If included the server will send SessionResumptionUpdate messages."""
+
+  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.
+      """
+
+  context_window_compression: Optional[ContextWindowCompressionConfigDict]
+  """Configures context window compression mechanism.
+
+      If included, server will compress context window to fit into given length."""
+
 
 LiveConnectConfigOrDict = Union[LiveConnectConfig, LiveConnectConfigDict]