google-genai 1.29.0__py3-none-any.whl → 1.31.0__py3-none-any.whl

google/genai/types.py

@@ -26,7 +26,7 @@ import types as builtin_types
 import typing
 from typing import Any, Callable, Literal, Optional, Sequence, Union, _UnionGenericAlias  # type: ignore
 import pydantic
-from pydantic import Field
+from pydantic import ConfigDict, Field, PrivateAttr, model_validator
 from typing_extensions import Self, TypedDict
 from . import _common
 
@@ -76,10 +76,20 @@ else:
     McpClientSession = None
     McpCallToolResult = None
 
+if typing.TYPE_CHECKING:
+  import yaml
+else:
+  try:
+    import yaml
+  except ImportError:
+    yaml = None
+
 logger = logging.getLogger('google_genai.types')
 
 T = typing.TypeVar('T', bound='GenerateContentResponse')
 
+MetricSubclass = typing.TypeVar('MetricSubclass', bound='Metric')
+
 
 class Outcome(_common.CaseInSensitiveEnum):
   """Required. Outcome of the code execution."""
@@ -223,15 +233,6 @@ class ApiSpec(_common.CaseInSensitiveEnum):
   """Elastic search API spec."""
 
 
-class Environment(_common.CaseInSensitiveEnum):
-  """Required. The environment being operated."""
-
-  ENVIRONMENT_UNSPECIFIED = 'ENVIRONMENT_UNSPECIFIED'
-  """Defaults to browser."""
-  ENVIRONMENT_BROWSER = 'ENVIRONMENT_BROWSER'
-  """Operates in a web browser."""
-
-
 class UrlRetrievalStatus(_common.CaseInSensitiveEnum):
   """Status of the url retrieval."""
 
@@ -398,6 +399,17 @@ class JobState(_common.CaseInSensitiveEnum):
   """The job is partially succeeded, some results may be missing due to errors."""
 
 
+class TuningMode(_common.CaseInSensitiveEnum):
+  """Tuning mode."""
+
+  TUNING_MODE_UNSPECIFIED = 'TUNING_MODE_UNSPECIFIED'
+  """Tuning mode is unspecified."""
+  TUNING_MODE_FULL = 'TUNING_MODE_FULL'
+  """Full fine-tuning mode."""
+  TUNING_MODE_PEFT_ADAPTER = 'TUNING_MODE_PEFT_ADAPTER'
+  """PEFT adapter tuning mode."""
+
+
 class AdapterSize(_common.CaseInSensitiveEnum):
   """Optional. Adapter size for tuning."""
 
@@ -417,6 +429,22 @@ class AdapterSize(_common.CaseInSensitiveEnum):
   """Adapter size 32."""
 
 
+class JSONSchemaType(Enum):
+  """The type of the data supported by JSON Schema.
+
+  The values of the enums are lower case strings, while the values of the enums
+  for the Type class are upper case strings.
+  """
+
+  NULL = 'null'
+  BOOLEAN = 'boolean'
+  OBJECT = 'object'
+  ARRAY = 'array'
+  NUMBER = 'number'
+  INTEGER = 'integer'
+  STRING = 'string'
+
+
 class FeatureSelectionPreference(_common.CaseInSensitiveEnum):
   """Options for feature selection preference."""
 
@@ -448,6 +476,15 @@ class DynamicRetrievalConfigMode(_common.CaseInSensitiveEnum):
   """Run retrieval only when system decides it is necessary."""
 
 
+class Environment(_common.CaseInSensitiveEnum):
+  """The environment being operated."""
+
+  ENVIRONMENT_UNSPECIFIED = 'ENVIRONMENT_UNSPECIFIED'
+  """Defaults to browser."""
+  ENVIRONMENT_BROWSER = 'ENVIRONMENT_BROWSER'
+  """Operates in a web browser."""
+
+
 class FunctionCallingConfigMode(_common.CaseInSensitiveEnum):
   """Config for the function calling config mode."""
 
@@ -543,6 +580,16 @@ class EditMode(_common.CaseInSensitiveEnum):
   EDIT_MODE_PRODUCT_IMAGE = 'EDIT_MODE_PRODUCT_IMAGE'
 
 
+class SegmentMode(_common.CaseInSensitiveEnum):
+  """Enum that represents the segmentation mode."""
+
+  FOREGROUND = 'FOREGROUND'
+  BACKGROUND = 'BACKGROUND'
+  PROMPT = 'PROMPT'
+  SEMANTIC = 'SEMANTIC'
+  INTERACTIVE = 'INTERACTIVE'
+
+
 class VideoCompressionQuality(_common.CaseInSensitiveEnum):
   """Enum that controls the compression quality of the generated videos."""
 
@@ -588,6 +635,19 @@ class MediaModality(_common.CaseInSensitiveEnum):
   """Document, e.g. PDF."""
 
 
+class FunctionResponseScheduling(_common.CaseInSensitiveEnum):
+  """Specifies how the response should be scheduled in the conversation."""
+
+  SCHEDULING_UNSPECIFIED = 'SCHEDULING_UNSPECIFIED'
+  """This value is unused."""
+  SILENT = 'SILENT'
+  """Only add the result to the conversation context, do not interrupt or trigger generation."""
+  WHEN_IDLE = 'WHEN_IDLE'
+  """Add the result to the conversation context, and prompt to generate output without interrupting ongoing generation."""
+  INTERRUPT = 'INTERRUPT'
+  """Add the result to the conversation context, interrupt ongoing generation and prompt to generate output."""
+
+
 class StartSensitivity(_common.CaseInSensitiveEnum):
   """Start of speech sensitivity."""
 
@@ -632,19 +692,6 @@ class TurnCoverage(_common.CaseInSensitiveEnum):
   """The users turn includes all realtime input since the last turn, including inactivity (e.g. silence on the audio stream)."""
 
 
-class FunctionResponseScheduling(_common.CaseInSensitiveEnum):
-  """Specifies how the response should be scheduled in the conversation."""
-
-  SCHEDULING_UNSPECIFIED = 'SCHEDULING_UNSPECIFIED'
-  """This value is unused."""
-  SILENT = 'SILENT'
-  """Only add the result to the conversation context, do not interrupt or trigger generation."""
-  WHEN_IDLE = 'WHEN_IDLE'
-  """Add the result to the conversation context, and prompt to generate output without interrupting ongoing generation."""
-  INTERRUPT = 'INTERRUPT'
-  """Add the result to the conversation context, interrupt ongoing generation and prompt to generate output."""
-
-
 class Scale(_common.CaseInSensitiveEnum):
   """Scale of the generated music."""
 
@@ -1131,67 +1178,6 @@ class Content(_common.BaseModel):
   )
 
 
-class UserContent(Content):
-  """UserContent facilitates the creation of a Content object with a user role.
-
-  Example usages:
-
-
-  - Create a user Content object with a string:
-    user_content = UserContent("Why is the sky blue?")
-  - Create a user Content object with a file data Part object:
-    user_content = UserContent(Part.from_uri(file_uril="gs://bucket/file.txt",
-    mime_type="text/plain"))
-  - Create a user Content object with byte data Part object:
-    user_content = UserContent(Part.from_bytes(data=b"Hello, World!",
-    mime_type="text/plain"))
-
-    You can create a user Content object using other classmethods in the Part
-    class as well.
-    You can also create a user Content using a list of Part objects or strings.
-  """
-
-  role: Literal['user'] = Field(default='user', init=False, frozen=True)
-  parts: list[Part] = Field()
-
-  def __init__(
-      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
-  ):
-    from . import _transformers as t
-
-    super().__init__(parts=t.t_parts(parts=parts))
-
-
-class ModelContent(Content):
-  """ModelContent facilitates the creation of a Content object with a model role.
-
-  Example usages:
-
-  - Create a model Content object with a string:
-    model_content = ModelContent("Why is the sky blue?")
-  - Create a model Content object with a file data Part object:
-    model_content = ModelContent(Part.from_uri(file_uril="gs://bucket/file.txt",
-    mime_type="text/plain"))
-  - Create a model Content object with byte data Part object:
-    model_content = ModelContent(Part.from_bytes(data=b"Hello, World!",
-    mime_type="text/plain"))
-
-    You can create a model Content object using other classmethods in the Part
-    class as well.
-    You can also create a model Content using a list of Part objects or strings.
-  """
-
-  role: Literal['model'] = Field(default='model', init=False, frozen=True)
-  parts: list[Part] = Field()
-
-  def __init__(
-      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
-  ):
-    from . import _transformers as t
-
-    super().__init__(parts=t.t_parts(parts=parts))
-
-
 class ContentDict(TypedDict, total=False):
   """Contains the multi-part content of a message."""
 
@@ -1334,23 +1320,7 @@ class HttpOptionsDict(TypedDict, total=False):
 HttpOptionsOrDict = Union[HttpOptions, HttpOptionsDict]
 
 
-class JSONSchemaType(Enum):
-  """The type of the data supported by JSON Schema.
-
-  The values of the enums are lower case strings, while the values of the enums
-  for the Type class are upper case strings.
-  """
-
-  NULL = 'null'
-  BOOLEAN = 'boolean'
-  OBJECT = 'object'
-  ARRAY = 'array'
-  NUMBER = 'number'
-  INTEGER = 'integer'
-  STRING = 'string'
-
-
-class JSONSchema(pydantic.BaseModel):
+class JSONSchema(_common.BaseModel):
   """A subset of JSON Schema according to 2020-12 JSON Schema draft.
 
   Represents a subset of a JSON Schema object that is used by the Gemini model.
@@ -2237,7 +2207,16 @@ class FunctionDeclaration(_common.BaseModel):
       callable: Callable[..., Any],
       behavior: Optional[Behavior] = None,
   ) -> 'FunctionDeclaration':
-    """Converts a Callable to a FunctionDeclaration based on the client."""
+    """Converts a Callable to a FunctionDeclaration based on the client.
+
+    Note: For best results prefer
+    [Google-style
+    docstring](https://google.github.io/styleguide/pyguide.html#383-functions-and-methods)
+    when describing arguments. This function does **not** parse argument
+    descriptions into the property description slots of the resulting structure.
+    Instead it sends the whole docstring in the top-level function description.
+    Google-style docstring are closest to what the model is trained on.
+    """
     if client.vertexai:
       return cls.from_callable_with_api_option(
           callable=callable, api_option='VERTEX_AI', behavior=behavior
@@ -2325,6 +2304,11 @@ class GoogleSearch(_common.BaseModel):
       If customers set a start time, they must set an end time (and vice versa).
       """,
   )
+  exclude_domains: Optional[list[str]] = Field(
+      default=None,
+      description="""Optional. List of domains to be excluded from the search results.
+      The default limit is 2000 domains.""",
+  )
 
 
 class GoogleSearchDict(TypedDict, total=False):
@@ -2335,6 +2319,10 @@ class GoogleSearchDict(TypedDict, total=False):
       If customers set a start time, they must set an end time (and vice versa).
       """
 
+  exclude_domains: Optional[list[str]]
+  """Optional. List of domains to be excluded from the search results.
+      The default limit is 2000 domains."""
+
 
 GoogleSearchOrDict = Union[GoogleSearch, GoogleSearchDict]
 
@@ -2391,13 +2379,17 @@ GoogleSearchRetrievalOrDict = Union[
 class EnterpriseWebSearch(_common.BaseModel):
   """Tool to search public web data, powered by Vertex AI Search and Sec4 compliance."""
 
-  pass
+  exclude_domains: Optional[list[str]] = Field(
+      default=None,
+      description="""Optional. List of domains to be excluded from the search results. The default limit is 2000 domains.""",
+  )
 
 
 class EnterpriseWebSearchDict(TypedDict, total=False):
   """Tool to search public web data, powered by Vertex AI Search and Sec4 compliance."""
 
-  pass
+  exclude_domains: Optional[list[str]]
+  """Optional. List of domains to be excluded from the search results. The default limit is 2000 domains."""
 
 
 EnterpriseWebSearchOrDict = Union[EnterpriseWebSearch, EnterpriseWebSearchDict]
@@ -2607,6 +2599,24 @@ class UrlContextDict(TypedDict, total=False):
 UrlContextOrDict = Union[UrlContext, UrlContextDict]
 
 
+class ToolComputerUse(_common.BaseModel):
+  """Tool to support computer use."""
+
+  environment: Optional[Environment] = Field(
+      default=None, description="""Required. The environment being operated."""
+  )
+
+
+class ToolComputerUseDict(TypedDict, total=False):
+  """Tool to support computer use."""
+
+  environment: Optional[Environment]
+  """Required. The environment being operated."""
+
+
+ToolComputerUseOrDict = Union[ToolComputerUse, ToolComputerUseDict]
+
+
 class ApiAuthApiKeyConfig(_common.BaseModel):
   """The API secret."""
 
@@ -3167,24 +3177,6 @@ class ToolCodeExecutionDict(TypedDict, total=False):
 ToolCodeExecutionOrDict = Union[ToolCodeExecution, ToolCodeExecutionDict]
 
 
-class ToolComputerUse(_common.BaseModel):
-  """Tool to support computer use."""
-
-  environment: Optional[Environment] = Field(
-      default=None, description="""Required. The environment being operated."""
-  )
-
-
-class ToolComputerUseDict(TypedDict, total=False):
-  """Tool to support computer use."""
-
-  environment: Optional[Environment]
-  """Required. The environment being operated."""
-
-
-ToolComputerUseOrDict = Union[ToolComputerUse, ToolComputerUseDict]
-
-
 class Tool(_common.BaseModel):
   """Tool details of a tool that the model may use to generate a response."""
 
@@ -3219,13 +3211,15 @@ class Tool(_common.BaseModel):
       default=None,
       description="""Optional. Tool to support URL context retrieval.""",
   )
-  code_execution: Optional[ToolCodeExecution] = Field(
+  computer_use: Optional[ToolComputerUse] = Field(
       default=None,
-      description="""Optional. CodeExecution tool type. Enables the model to execute code as part of generation.""",
+      description="""Optional. Tool to support the model interacting directly with the
+      computer. If enabled, it automatically populates computer-use specific
+      Function Declarations.""",
   )
-  computer_use: Optional[ToolComputerUse] = Field(
+  code_execution: Optional[ToolCodeExecution] = Field(
       default=None,
-      description="""Optional. Tool to support the model interacting directly with the computer. If enabled, it automatically populates computer-use specific Function Declarations.""",
+      description="""Optional. CodeExecution tool type. Enables the model to execute code as part of generation.""",
   )
 
 
@@ -3256,12 +3250,14 @@ class ToolDict(TypedDict, total=False):
   url_context: Optional[UrlContextDict]
   """Optional. Tool to support URL context retrieval."""
 
+  computer_use: Optional[ToolComputerUseDict]
+  """Optional. Tool to support the model interacting directly with the
+      computer. If enabled, it automatically populates computer-use specific
+      Function Declarations."""
+
   code_execution: Optional[ToolCodeExecutionDict]
   """Optional. CodeExecution tool type. Enables the model to execute code as part of generation."""
 
-  computer_use: Optional[ToolComputerUseDict]
-  """Optional. Tool to support the model interacting directly with the computer. If enabled, it automatically populates computer-use specific Function Declarations."""
-
 
 ToolOrDict = Union[Tool, ToolDict]
 if _is_mcp_imported:
@@ -4485,66 +4481,235 @@ class UrlContextMetadataDict(TypedDict, total=False):
 UrlContextMetadataOrDict = Union[UrlContextMetadata, UrlContextMetadataDict]
 
 
-class RagChunkPageSpan(_common.BaseModel):
-  """Represents where the chunk starts and ends in the document."""
+class GroundingChunkMapsPlaceAnswerSourcesAuthorAttribution(_common.BaseModel):
+  """Author attribution for a photo or review."""
 
-  first_page: Optional[int] = Field(
-      default=None,
-      description="""Page where chunk starts in the document. Inclusive. 1-indexed.""",
+  display_name: Optional[str] = Field(
+      default=None, description="""Name of the author of the Photo or Review."""
   )
-  last_page: Optional[int] = Field(
+  photo_uri: Optional[str] = Field(
       default=None,
-      description="""Page where chunk ends in the document. Inclusive. 1-indexed.""",
+      description="""Profile photo URI of the author of the Photo or Review.""",
+  )
+  uri: Optional[str] = Field(
+      default=None, description="""URI of the author of the Photo or Review."""
   )
 
 
-class RagChunkPageSpanDict(TypedDict, total=False):
-  """Represents where the chunk starts and ends in the document."""
+class GroundingChunkMapsPlaceAnswerSourcesAuthorAttributionDict(
+    TypedDict, total=False
+):
+  """Author attribution for a photo or review."""
 
-  first_page: Optional[int]
-  """Page where chunk starts in the document. Inclusive. 1-indexed."""
+  display_name: Optional[str]
+  """Name of the author of the Photo or Review."""
 
-  last_page: Optional[int]
-  """Page where chunk ends in the document. Inclusive. 1-indexed."""
+  photo_uri: Optional[str]
+  """Profile photo URI of the author of the Photo or Review."""
+
+  uri: Optional[str]
+  """URI of the author of the Photo or Review."""
 
 
-RagChunkPageSpanOrDict = Union[RagChunkPageSpan, RagChunkPageSpanDict]
+GroundingChunkMapsPlaceAnswerSourcesAuthorAttributionOrDict = Union[
+    GroundingChunkMapsPlaceAnswerSourcesAuthorAttribution,
+    GroundingChunkMapsPlaceAnswerSourcesAuthorAttributionDict,
+]
 
 
-class RagChunk(_common.BaseModel):
-  """A RagChunk includes the content of a chunk of a RagFile, and associated metadata."""
+class GroundingChunkMapsPlaceAnswerSourcesReviewSnippet(_common.BaseModel):
+  """Encapsulates a review snippet."""
 
-  page_span: Optional[RagChunkPageSpan] = Field(
+  author_attribution: Optional[
+      GroundingChunkMapsPlaceAnswerSourcesAuthorAttribution
+  ] = Field(default=None, description="""This review's author.""")
+  flag_content_uri: Optional[str] = Field(
       default=None,
-      description="""If populated, represents where the chunk starts and ends in the document.""",
+      description="""A link where users can flag a problem with the review.""",
   )
-  text: Optional[str] = Field(
-      default=None, description="""The content of the chunk."""
+  google_maps_uri: Optional[str] = Field(
+      default=None, description="""A link to show the review on Google Maps."""
+  )
+  relative_publish_time_description: Optional[str] = Field(
+      default=None,
+      description="""A string of formatted recent time, expressing the review time relative to the current time in a form appropriate for the language and country.""",
+  )
+  review: Optional[str] = Field(
+      default=None,
+      description="""A reference representing this place review which may be used to look up this place review again.""",
   )
 
 
-class RagChunkDict(TypedDict, total=False):
-  """A RagChunk includes the content of a chunk of a RagFile, and associated metadata."""
+class GroundingChunkMapsPlaceAnswerSourcesReviewSnippetDict(
+    TypedDict, total=False
+):
+  """Encapsulates a review snippet."""
 
-  page_span: Optional[RagChunkPageSpanDict]
-  """If populated, represents where the chunk starts and ends in the document."""
+  author_attribution: Optional[
+      GroundingChunkMapsPlaceAnswerSourcesAuthorAttributionDict
+  ]
+  """This review's author."""
 
-  text: Optional[str]
-  """The content of the chunk."""
+  flag_content_uri: Optional[str]
+  """A link where users can flag a problem with the review."""
 
+  google_maps_uri: Optional[str]
+  """A link to show the review on Google Maps."""
 
-RagChunkOrDict = Union[RagChunk, RagChunkDict]
+  relative_publish_time_description: Optional[str]
+  """A string of formatted recent time, expressing the review time relative to the current time in a form appropriate for the language and country."""
 
+  review: Optional[str]
+  """A reference representing this place review which may be used to look up this place review again."""
 
-class GroundingChunkRetrievedContext(_common.BaseModel):
-  """Chunk from context retrieved by the retrieval tools."""
 
-  rag_chunk: Optional[RagChunk] = Field(
+GroundingChunkMapsPlaceAnswerSourcesReviewSnippetOrDict = Union[
+    GroundingChunkMapsPlaceAnswerSourcesReviewSnippet,
+    GroundingChunkMapsPlaceAnswerSourcesReviewSnippetDict,
+]
+
+
+class GroundingChunkMapsPlaceAnswerSources(_common.BaseModel):
+  """Sources used to generate the place answer."""
+
+  flag_content_uri: Optional[str] = Field(
       default=None,
-      description="""Additional context for the RAG retrieval result. This is only populated when using the RAG retrieval tool.""",
-  )
-  text: Optional[str] = Field(
-      default=None, description="""Text of the attribution."""
+      description="""A link where users can flag a problem with the generated answer.""",
+  )
+  review_snippets: Optional[
+      list[GroundingChunkMapsPlaceAnswerSourcesReviewSnippet]
+  ] = Field(
+      default=None,
+      description="""Snippets of reviews that are used to generate the answer.""",
+  )
+
+
+class GroundingChunkMapsPlaceAnswerSourcesDict(TypedDict, total=False):
+  """Sources used to generate the place answer."""
+
+  flag_content_uri: Optional[str]
+  """A link where users can flag a problem with the generated answer."""
+
+  review_snippets: Optional[
+      list[GroundingChunkMapsPlaceAnswerSourcesReviewSnippetDict]
+  ]
+  """Snippets of reviews that are used to generate the answer."""
+
+
+GroundingChunkMapsPlaceAnswerSourcesOrDict = Union[
+    GroundingChunkMapsPlaceAnswerSources,
+    GroundingChunkMapsPlaceAnswerSourcesDict,
+]
+
+
+class GroundingChunkMaps(_common.BaseModel):
+  """Chunk from Google Maps."""
+
+  place_answer_sources: Optional[GroundingChunkMapsPlaceAnswerSources] = Field(
+      default=None,
+      description="""Sources used to generate the place answer. This includes review snippets and photos that were used to generate the answer, as well as uris to flag content.""",
+  )
+  place_id: Optional[str] = Field(
+      default=None,
+      description="""This Place's resource name, in `places/{place_id}` format. Can be used to look up the Place.""",
+  )
+  text: Optional[str] = Field(
+      default=None, description="""Text of the chunk."""
+  )
+  title: Optional[str] = Field(
+      default=None, description="""Title of the chunk."""
+  )
+  uri: Optional[str] = Field(
+      default=None, description="""URI reference of the chunk."""
+  )
+
+
+class GroundingChunkMapsDict(TypedDict, total=False):
+  """Chunk from Google Maps."""
+
+  place_answer_sources: Optional[GroundingChunkMapsPlaceAnswerSourcesDict]
+  """Sources used to generate the place answer. This includes review snippets and photos that were used to generate the answer, as well as uris to flag content."""
+
+  place_id: Optional[str]
+  """This Place's resource name, in `places/{place_id}` format. Can be used to look up the Place."""
+
+  text: Optional[str]
+  """Text of the chunk."""
+
+  title: Optional[str]
+  """Title of the chunk."""
+
+  uri: Optional[str]
+  """URI reference of the chunk."""
+
+
+GroundingChunkMapsOrDict = Union[GroundingChunkMaps, GroundingChunkMapsDict]
+
+
+class RagChunkPageSpan(_common.BaseModel):
+  """Represents where the chunk starts and ends in the document."""
+
+  first_page: Optional[int] = Field(
+      default=None,
+      description="""Page where chunk starts in the document. Inclusive. 1-indexed.""",
+  )
+  last_page: Optional[int] = Field(
+      default=None,
+      description="""Page where chunk ends in the document. Inclusive. 1-indexed.""",
+  )
+
+
+class RagChunkPageSpanDict(TypedDict, total=False):
+  """Represents where the chunk starts and ends in the document."""
+
+  first_page: Optional[int]
+  """Page where chunk starts in the document. Inclusive. 1-indexed."""
+
+  last_page: Optional[int]
+  """Page where chunk ends in the document. Inclusive. 1-indexed."""
+
+
+RagChunkPageSpanOrDict = Union[RagChunkPageSpan, RagChunkPageSpanDict]
+
+
+class RagChunk(_common.BaseModel):
+  """A RagChunk includes the content of a chunk of a RagFile, and associated metadata."""
+
+  page_span: Optional[RagChunkPageSpan] = Field(
+      default=None,
+      description="""If populated, represents where the chunk starts and ends in the document.""",
+  )
+  text: Optional[str] = Field(
+      default=None, description="""The content of the chunk."""
+  )
+
+
+class RagChunkDict(TypedDict, total=False):
+  """A RagChunk includes the content of a chunk of a RagFile, and associated metadata."""
+
+  page_span: Optional[RagChunkPageSpanDict]
+  """If populated, represents where the chunk starts and ends in the document."""
+
+  text: Optional[str]
+  """The content of the chunk."""
+
+
+RagChunkOrDict = Union[RagChunk, RagChunkDict]
+
+
+class GroundingChunkRetrievedContext(_common.BaseModel):
+  """Chunk from context retrieved by the retrieval tools."""
+
+  document_name: Optional[str] = Field(
+      default=None,
+      description="""Output only. The full document name for the referenced Vertex AI Search document.""",
+  )
+  rag_chunk: Optional[RagChunk] = Field(
+      default=None,
+      description="""Additional context for the RAG retrieval result. This is only populated when using the RAG retrieval tool.""",
+  )
+  text: Optional[str] = Field(
+      default=None, description="""Text of the attribution."""
   )
   title: Optional[str] = Field(
       default=None, description="""Title of the attribution."""
@@ -4557,6 +4722,9 @@ class GroundingChunkRetrievedContext(_common.BaseModel):
 class GroundingChunkRetrievedContextDict(TypedDict, total=False):
   """Chunk from context retrieved by the retrieval tools."""
 
+  document_name: Optional[str]
+  """Output only. The full document name for the referenced Vertex AI Search document."""
+
   rag_chunk: Optional[RagChunkDict]
   """Additional context for the RAG retrieval result. This is only populated when using the RAG retrieval tool."""
 
@@ -4608,6 +4776,9 @@ GroundingChunkWebOrDict = Union[GroundingChunkWeb, GroundingChunkWebDict]
 class GroundingChunk(_common.BaseModel):
   """Grounding chunk."""
 
+  maps: Optional[GroundingChunkMaps] = Field(
+      default=None, description="""Grounding chunk from Google Maps."""
+  )
   retrieved_context: Optional[GroundingChunkRetrievedContext] = Field(
       default=None,
       description="""Grounding chunk from context retrieved by the retrieval tools.""",
@@ -4620,6 +4791,9 @@ class GroundingChunk(_common.BaseModel):
 class GroundingChunkDict(TypedDict, total=False):
   """Grounding chunk."""
 
+  maps: Optional[GroundingChunkMapsDict]
+  """Grounding chunk from Google Maps."""
+
   retrieved_context: Optional[GroundingChunkRetrievedContextDict]
   """Grounding chunk from context retrieved by the retrieval tools."""
 
@@ -4751,6 +4925,10 @@ SearchEntryPointOrDict = Union[SearchEntryPoint, SearchEntryPointDict]
 class GroundingMetadata(_common.BaseModel):
   """Metadata returned to client when grounding is enabled."""
 
+  google_maps_widget_context_token: Optional[str] = Field(
+      default=None,
+      description="""Optional. Output only. Resource name of the Google Maps widget context token to be used with the PlacesContextElement widget to render contextual data. This is populated only for Google Maps grounding.""",
+  )
   grounding_chunks: Optional[list[GroundingChunk]] = Field(
       default=None,
       description="""List of supporting references retrieved from specified grounding source.""",
@@ -4778,6 +4956,9 @@ class GroundingMetadata(_common.BaseModel):
 class GroundingMetadataDict(TypedDict, total=False):
   """Metadata returned to client when grounding is enabled."""
 
+  google_maps_widget_context_token: Optional[str]
+  """Optional. Output only. Resource name of the Google Maps widget context token to be used with the PlacesContextElement widget to render contextual data. This is populated only for Google Maps grounding."""
+
   grounding_chunks: Optional[list[GroundingChunkDict]]
   """List of supporting references retrieved from specified grounding source."""
 
@@ -7009,6 +7190,236 @@ RecontextImageResponseOrDict = Union[
 ]
 
 
+class ScribbleImage(_common.BaseModel):
+  """An image mask representing a brush scribble."""
+
+  image: Optional[Image] = Field(
+      default=None,
+      description="""The brush scribble to guide segmentation. Valid for the interactive mode.""",
+  )
+
+
+class ScribbleImageDict(TypedDict, total=False):
+  """An image mask representing a brush scribble."""
+
+  image: Optional[ImageDict]
+  """The brush scribble to guide segmentation. Valid for the interactive mode."""
+
+
+ScribbleImageOrDict = Union[ScribbleImage, ScribbleImageDict]
+
+
+class SegmentImageSource(_common.BaseModel):
+  """A set of source input(s) for image segmentation."""
+
+  prompt: Optional[str] = Field(
+      default=None,
+      description="""A text prompt for guiding the model during image segmentation.
+      Required for prompt mode and semantic mode, disallowed for other modes.""",
+  )
+  image: Optional[Image] = Field(
+      default=None, description="""The image to be segmented."""
+  )
+  scribble_image: Optional[ScribbleImage] = Field(
+      default=None,
+      description="""The brush scribble to guide segmentation.
+      Required for the interactive mode, disallowed for other modes.""",
+  )
+
+
+class SegmentImageSourceDict(TypedDict, total=False):
+  """A set of source input(s) for image segmentation."""
+
+  prompt: Optional[str]
+  """A text prompt for guiding the model during image segmentation.
+      Required for prompt mode and semantic mode, disallowed for other modes."""
+
+  image: Optional[ImageDict]
+  """The image to be segmented."""
+
+  scribble_image: Optional[ScribbleImageDict]
+  """The brush scribble to guide segmentation.
+      Required for the interactive mode, disallowed for other modes."""
+
+
+SegmentImageSourceOrDict = Union[SegmentImageSource, SegmentImageSourceDict]
+
+
+class SegmentImageConfig(_common.BaseModel):
+  """Configuration for segmenting an image."""
+
+  http_options: Optional[HttpOptions] = Field(
+      default=None, description="""Used to override HTTP request options."""
+  )
+  mode: Optional[SegmentMode] = Field(
+      default=None, description="""The segmentation mode to use."""
+  )
+  max_predictions: Optional[int] = Field(
+      default=None,
+      description="""The maximum number of predictions to return up to, by top
+      confidence score.""",
+  )
+  confidence_threshold: Optional[float] = Field(
+      default=None,
+      description="""The confidence score threshold for the detections as a decimal
+      value. Only predictions with a confidence score higher than this
+      threshold will be returned.""",
+  )
+  mask_dilation: Optional[float] = Field(
+      default=None,
+      description="""A decimal value representing how much dilation to apply to the
+      masks. 0 for no dilation. 1.0 means the masked area covers the whole
+      image.""",
+  )
+  binary_color_threshold: Optional[float] = Field(
+      default=None,
+      description="""The binary color threshold to apply to the masks. The threshold
+      can be set to a decimal value between 0 and 255 non-inclusive.
+      Set to -1 for no binary color thresholding.""",
+  )
+
+
+class SegmentImageConfigDict(TypedDict, total=False):
+  """Configuration for segmenting an image."""
+
+  http_options: Optional[HttpOptionsDict]
+  """Used to override HTTP request options."""
+
+  mode: Optional[SegmentMode]
+  """The segmentation mode to use."""
+
+  max_predictions: Optional[int]
+  """The maximum number of predictions to return up to, by top
+      confidence score."""
+
+  confidence_threshold: Optional[float]
+  """The confidence score threshold for the detections as a decimal
+      value. Only predictions with a confidence score higher than this
+      threshold will be returned."""
+
+  mask_dilation: Optional[float]
+  """A decimal value representing how much dilation to apply to the
+      masks. 0 for no dilation. 1.0 means the masked area covers the whole
+      image."""
+
+  binary_color_threshold: Optional[float]
+  """The binary color threshold to apply to the masks. The threshold
+      can be set to a decimal value between 0 and 255 non-inclusive.
+      Set to -1 for no binary color thresholding."""
+
+
+SegmentImageConfigOrDict = Union[SegmentImageConfig, SegmentImageConfigDict]
+
+
+class _SegmentImageParameters(_common.BaseModel):
+  """The parameters for segmenting an image."""
+
+  model: Optional[str] = Field(
+      default=None,
+      description="""ID of the model to use. For a list of models, see `Google models
+    <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models>`_.""",
+  )
+  source: Optional[SegmentImageSource] = Field(
+      default=None,
+      description="""A set of source input(s) for image segmentation.""",
+  )
+  config: Optional[SegmentImageConfig] = Field(
+      default=None, description="""Configuration for image segmentation."""
+  )
+
+
+class _SegmentImageParametersDict(TypedDict, total=False):
+  """The parameters for segmenting an image."""
+
+  model: Optional[str]
+  """ID of the model to use. For a list of models, see `Google models
+    <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models>`_."""
+
+  source: Optional[SegmentImageSourceDict]
+  """A set of source input(s) for image segmentation."""
+
+  config: Optional[SegmentImageConfigDict]
+  """Configuration for image segmentation."""
+
+
+_SegmentImageParametersOrDict = Union[
+    _SegmentImageParameters, _SegmentImageParametersDict
+]
+
+
+class EntityLabel(_common.BaseModel):
+  """An entity representing the segmented area."""
+
+  label: Optional[str] = Field(
+      default=None, description="""The label of the segmented entity."""
+  )
+  score: Optional[float] = Field(
+      default=None,
+      description="""The confidence score of the detected label.""",
+  )
+
+
+class EntityLabelDict(TypedDict, total=False):
+  """An entity representing the segmented area."""
+
+  label: Optional[str]
+  """The label of the segmented entity."""
+
+  score: Optional[float]
+  """The confidence score of the detected label."""
+
+
+EntityLabelOrDict = Union[EntityLabel, EntityLabelDict]
+
+
+class GeneratedImageMask(_common.BaseModel):
+  """A generated image mask."""
+
+  mask: Optional[Image] = Field(
+      default=None, description="""The generated image mask."""
+  )
+  labels: Optional[list[EntityLabel]] = Field(
+      default=None,
+      description="""The detected entities on the segmented area.""",
+  )
+
+
+class GeneratedImageMaskDict(TypedDict, total=False):
+  """A generated image mask."""
+
+  mask: Optional[ImageDict]
+  """The generated image mask."""
+
+  labels: Optional[list[EntityLabelDict]]
+  """The detected entities on the segmented area."""
+
+
+GeneratedImageMaskOrDict = Union[GeneratedImageMask, GeneratedImageMaskDict]
+
+
+class SegmentImageResponse(_common.BaseModel):
+  """The output images response."""
+
+  generated_masks: Optional[list[GeneratedImageMask]] = Field(
+      default=None,
+      description="""List of generated image masks.
+      """,
+  )
+
+
+class SegmentImageResponseDict(TypedDict, total=False):
+  """The output images response."""
+
+  generated_masks: Optional[list[GeneratedImageMaskDict]]
+  """List of generated image masks.
+      """
+
+
+SegmentImageResponseOrDict = Union[
+    SegmentImageResponse, SegmentImageResponseDict
+]
+
+
 class GetModelConfig(_common.BaseModel):
   """Optional parameters for models.get method."""
 
@@ -7437,7 +7848,7 @@ class GenerationConfigThinkingConfig(_common.BaseModel):
   )
   thinking_budget: Optional[int] = Field(
       default=None,
-      description="""Optional. Indicates the thinking budget in tokens. This is only applied when enable_thinking is true.""",
+      description="""Optional. Indicates the thinking budget in tokens.""",
   )
 
 
@@ -7448,7 +7859,7 @@ class GenerationConfigThinkingConfigDict(TypedDict, total=False):
   """Optional. Indicates whether to include thoughts in the response. If true, thoughts are returned only when available."""
 
   thinking_budget: Optional[int]
-  """Optional. Indicates the thinking budget in tokens. This is only applied when enable_thinking is true."""
+  """Optional. Indicates the thinking budget in tokens."""
 
 
 GenerationConfigThinkingConfigOrDict = Union[
@@ -7943,6 +8354,40 @@ class VideoDict(TypedDict, total=False):
 VideoOrDict = Union[Video, VideoDict]
 
 
+class VideoGenerationReferenceImage(_common.BaseModel):
+  """A reference image for video generation."""
+
+  image: Optional[Image] = Field(
+      default=None,
+      description="""The reference image.
+      """,
+  )
+  reference_type: Optional[str] = Field(
+      default=None,
+      description="""The type of the reference image, which defines how the reference
+      image will be used to generate the video. Supported values are 'asset'
+      or 'style'.""",
+  )
+
+
+class VideoGenerationReferenceImageDict(TypedDict, total=False):
+  """A reference image for video generation."""
+
+  image: Optional[ImageDict]
+  """The reference image.
+      """
+
+  reference_type: Optional[str]
+  """The type of the reference image, which defines how the reference
+      image will be used to generate the video. Supported values are 'asset'
+      or 'style'."""
+
+
+VideoGenerationReferenceImageOrDict = Union[
+    VideoGenerationReferenceImage, VideoGenerationReferenceImageDict
+]
+
+
 class GenerateVideosConfig(_common.BaseModel):
   """Configuration for generating videos."""
 
@@ -7998,6 +8443,14 @@ class GenerateVideosConfig(_common.BaseModel):
       default=None,
       description="""Image to use as the last frame of generated videos. Only supported for image to video use cases.""",
   )
+  reference_images: Optional[list[VideoGenerationReferenceImage]] = Field(
+      default=None,
+      description="""The images to use as the references to generate the videos.
+      If this field is provided, the text prompt field must also be provided.
+      The image, video, or last_frame field are not supported. Each image must
+      be associated with a type. Veo 2 supports up to 3 asset images *or* 1
+      style image.""",
+  )
   compression_quality: Optional[VideoCompressionQuality] = Field(
       default=None,
       description="""Compression quality of the generated videos.""",
@@ -8049,6 +8502,13 @@ class GenerateVideosConfigDict(TypedDict, total=False):
   last_frame: Optional[ImageDict]
   """Image to use as the last frame of generated videos. Only supported for image to video use cases."""
 
+  reference_images: Optional[list[VideoGenerationReferenceImageDict]]
+  """The images to use as the references to generate the videos.
+      If this field is provided, the text prompt field must also be provided.
+      The image, video, or last_frame field are not supported. Each image must
+      be associated with a type. Veo 2 supports up to 3 asset images *or* 1
+      style image."""
+
   compression_quality: Optional[VideoCompressionQuality]
   """Compression quality of the generated videos."""
 
@@ -8360,7 +8820,7 @@ class TunedModel(_common.BaseModel):
 
   model: Optional[str] = Field(
       default=None,
-      description="""Output only. The resource name of the TunedModel. Format: `projects/{project}/locations/{location}/models/{model}`.""",
+      description="""Output only. The resource name of the TunedModel. Format: `projects/{project}/locations/{location}/models/{model}@{version_id}` When tuning from a base model, the version_id will be 1. For continuous tuning, the version id will be incremented by 1 from the last version id in the parent model. E.g., `projects/{project}/locations/{location}/models/{model}@{last_version_id + 1}`""",
   )
   endpoint: Optional[str] = Field(
       default=None,
@@ -8377,7 +8837,7 @@ class TunedModel(_common.BaseModel):
 class TunedModelDict(TypedDict, total=False):
 
   model: Optional[str]
-  """Output only. The resource name of the TunedModel. Format: `projects/{project}/locations/{location}/models/{model}`."""
+  """Output only. The resource name of the TunedModel. Format: `projects/{project}/locations/{location}/models/{model}@{version_id}` When tuning from a base model, the version_id will be 1. For continuous tuning, the version id will be incremented by 1 from the last version id in the parent model. E.g., `projects/{project}/locations/{location}/models/{model}@{last_version_id + 1}`"""
 
   endpoint: Optional[str]
   """Output only. A resource name of an Endpoint. Format: `projects/{project}/locations/{location}/endpoints/{endpoint}`."""
@@ -8391,7 +8851,275 @@ class TunedModelDict(TypedDict, total=False):
 TunedModelOrDict = Union[TunedModel, TunedModelDict]
 
 
-class GoogleRpcStatus(_common.BaseModel):
+class GcsDestination(_common.BaseModel):
+  """The Google Cloud Storage location where the output is to be written to."""
+
+  output_uri_prefix: Optional[str] = Field(
+      default=None,
+      description="""Required. Google Cloud Storage URI to output directory. If the uri doesn't end with '/', a '/' will be automatically appended. The directory is created if it doesn't exist.""",
+  )
+
+  @pydantic.model_validator(mode='after')
+  def _validate_gcs_path(self) -> 'GcsDestination':
+    if self.output_uri_prefix and not self.output_uri_prefix.startswith(
+        'gs://'
+    ):
+      raise ValueError(
+          'output_uri_prefix must be a valid GCS path starting with "gs://".'
+      )
+    return self
+
+
+class GcsDestinationDict(TypedDict, total=False):
+  """The Google Cloud Storage location where the output is to be written to."""
+
+  output_uri_prefix: Optional[str]
+  """Required. Google Cloud Storage URI to output directory. If the uri doesn't end with '/', a '/' will be automatically appended. The directory is created if it doesn't exist."""
+
+
+GcsDestinationOrDict = Union[GcsDestination, GcsDestinationDict]
+
+
+class OutputConfig(_common.BaseModel):
+  """Config for evaluation output."""
+
+  gcs_destination: Optional[GcsDestination] = Field(
+      default=None,
+      description="""Cloud storage destination for evaluation output.""",
+  )
+
+
+class OutputConfigDict(TypedDict, total=False):
+  """Config for evaluation output."""
+
+  gcs_destination: Optional[GcsDestinationDict]
+  """Cloud storage destination for evaluation output."""
+
+
+OutputConfigOrDict = Union[OutputConfig, OutputConfigDict]
+
+
+class AutoraterConfig(_common.BaseModel):
+  """Autorater config used for evaluation."""
+
+  sampling_count: Optional[int] = Field(
+      default=None,
+      description="""Number of samples for each instance in the dataset.
+  If not specified, the default is 4. Minimum value is 1, maximum value
+  is 32.""",
+  )
+  flip_enabled: Optional[bool] = Field(
+      default=None,
+      description="""Optional. Default is true. Whether to flip the candidate and baseline
+  responses. This is only applicable to the pairwise metric. If enabled, also
+  provide PairwiseMetricSpec.candidate_response_field_name and
+  PairwiseMetricSpec.baseline_response_field_name. When rendering
+  PairwiseMetricSpec.metric_prompt_template, the candidate and baseline
+  fields will be flipped for half of the samples to reduce bias.""",
+  )
+  autorater_model: Optional[str] = Field(
+      default=None,
+      description="""The fully qualified name of the publisher model or tuned autorater
+  endpoint to use.
+
+  Publisher model format:
+  `projects/{project}/locations/{location}/publishers/*/models/*`
+
+  Tuned model endpoint format:
+  `projects/{project}/locations/{location}/endpoints/{endpoint}`""",
+  )
+
+
+class AutoraterConfigDict(TypedDict, total=False):
+  """Autorater config used for evaluation."""
+
+  sampling_count: Optional[int]
+  """Number of samples for each instance in the dataset.
+  If not specified, the default is 4. Minimum value is 1, maximum value
+  is 32."""
+
+  flip_enabled: Optional[bool]
+  """Optional. Default is true. Whether to flip the candidate and baseline
+  responses. This is only applicable to the pairwise metric. If enabled, also
+  provide PairwiseMetricSpec.candidate_response_field_name and
+  PairwiseMetricSpec.baseline_response_field_name. When rendering
+  PairwiseMetricSpec.metric_prompt_template, the candidate and baseline
+  fields will be flipped for half of the samples to reduce bias."""
+
+  autorater_model: Optional[str]
+  """The fully qualified name of the publisher model or tuned autorater
+  endpoint to use.
+
+  Publisher model format:
+  `projects/{project}/locations/{location}/publishers/*/models/*`
+
+  Tuned model endpoint format:
+  `projects/{project}/locations/{location}/endpoints/{endpoint}`"""
+
+
+AutoraterConfigOrDict = Union[AutoraterConfig, AutoraterConfigDict]
+
+
+class Metric(_common.BaseModel):
+  """The metric used for evaluation."""
+
+  name: Optional[str] = Field(
+      default=None, description="""The name of the metric."""
+  )
+  custom_function: Optional[Callable[..., Any]] = Field(
+      default=None,
+      description="""The custom function that defines the end-to-end logic for metric computation.""",
+  )
+  prompt_template: Optional[str] = Field(
+      default=None, description="""The prompt template for the metric."""
+  )
+  judge_model_system_instruction: Optional[str] = Field(
+      default=None,
+      description="""The system instruction for the judge model.""",
+  )
+  return_raw_output: Optional[bool] = Field(
+      default=None,
+      description="""Whether to return the raw output from the judge model.""",
+  )
+  parse_and_reduce_fn: Optional[Callable[..., Any]] = Field(
+      default=None,
+      description="""The parse and reduce function for the judge model.""",
+  )
+  aggregate_summary_fn: Optional[Callable[..., Any]] = Field(
+      default=None,
+      description="""The aggregate summary function for the judge model.""",
+  )
+
+  # Allow extra fields to support metric-specific config fields.
+  model_config = ConfigDict(extra='allow')
+
+  _is_predefined: bool = PrivateAttr(default=False)
+  """A boolean indicating whether the metric is predefined."""
+
+  _config_source: Optional[str] = PrivateAttr(default=None)
+  """An optional string indicating the source of the metric configuration."""
+
+  _version: Optional[str] = PrivateAttr(default=None)
+  """An optional string indicating the version of the metric."""
+
+  @model_validator(mode='after')  # type: ignore[arg-type]
+  @classmethod
+  def validate_name(cls, model: 'Metric') -> 'Metric':
+    if not model.name:
+      raise ValueError('Metric name cannot be empty.')
+    model.name = model.name.lower()
+    return model
+
+  def to_yaml_file(self, file_path: str, version: Optional[str] = None) -> None:
+    """Dumps the metric object to a YAML file.
+
+    Args:
+        file_path: The path to the YAML file.
+        version: Optional version string to include in the YAML output.
+
+    Raises:
+        ImportError: If the pyyaml library is not installed.
+    """
+    if yaml is None:
+      raise ImportError(
+          'YAML serialization requires the pyyaml library. Please install'
+          " it using 'pip install google-cloud-aiplatform[evaluation]'."
+      )
+
+    fields_to_exclude_callables = set()
+    for field_name, field_info in self.model_fields.items():
+      annotation = field_info.annotation
+      origin = typing.get_origin(annotation)
+
+      is_field_callable_type = False
+      if annotation is Callable or origin is Callable:  # type: ignore[comparison-overlap]
+        is_field_callable_type = True
+      elif origin is Union:
+        args = typing.get_args(annotation)
+        if any(
+            arg is Callable or typing.get_origin(arg) is Callable
+            for arg in args
+        ):
+          is_field_callable_type = True
+
+      if is_field_callable_type:
+        fields_to_exclude_callables.add(field_name)
+
+    data_to_dump = self.model_dump(
+        exclude_unset=True,
+        exclude_none=True,
+        mode='json',
+        exclude=fields_to_exclude_callables
+        if fields_to_exclude_callables
+        else None,
+    )
+
+    if version:
+      data_to_dump['version'] = version
+
+    with open(file_path, 'w', encoding='utf-8') as f:
+      yaml.dump(data_to_dump, f, sort_keys=False, allow_unicode=True)
+
+
+class MetricDict(TypedDict, total=False):
+  """The metric used for evaluation."""
+
+  name: Optional[str]
+  """The name of the metric."""
+
+  custom_function: Optional[Callable[..., Any]]
+  """The custom function that defines the end-to-end logic for metric computation."""
+
+  prompt_template: Optional[str]
+  """The prompt template for the metric."""
+
+  judge_model_system_instruction: Optional[str]
+  """The system instruction for the judge model."""
+
+  return_raw_output: Optional[bool]
+  """Whether to return the raw output from the judge model."""
+
+  parse_and_reduce_fn: Optional[Callable[..., Any]]
+  """The parse and reduce function for the judge model."""
+
+  aggregate_summary_fn: Optional[Callable[..., Any]]
+  """The aggregate summary function for the judge model."""
+
+
+MetricOrDict = Union[Metric, MetricDict]
+
+
+class EvaluationConfig(_common.BaseModel):
+  """Evaluation config for tuning."""
+
+  metrics: Optional[list[Metric]] = Field(
+      default=None, description="""The metrics used for evaluation."""
+  )
+  output_config: Optional[OutputConfig] = Field(
+      default=None, description="""Config for evaluation output."""
+  )
+  autorater_config: Optional[AutoraterConfig] = Field(
+      default=None, description="""Autorater config for evaluation."""
+  )
+
+
+class EvaluationConfigDict(TypedDict, total=False):
+  """Evaluation config for tuning."""
+
+  metrics: Optional[list[MetricDict]]
+  """The metrics used for evaluation."""
+
+  output_config: Optional[OutputConfigDict]
+  """Config for evaluation output."""
+
+  autorater_config: Optional[AutoraterConfigDict]
+  """Autorater config for evaluation."""
+
+
+EvaluationConfigOrDict = Union[EvaluationConfig, EvaluationConfigDict]
+
+
+class GoogleRpcStatus(_common.BaseModel):
   """The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs.
 
   It is used by [gRPC](https://github.com/grpc). Each `Status` message contains
@@ -8436,19 +9164,60 @@ class GoogleRpcStatusDict(TypedDict, total=False):
 GoogleRpcStatusOrDict = Union[GoogleRpcStatus, GoogleRpcStatusDict]
 
 
+class PreTunedModel(_common.BaseModel):
+  """A pre-tuned model for continuous tuning."""
+
+  base_model: Optional[str] = Field(
+      default=None,
+      description="""Output only. The name of the base model this PreTunedModel was tuned from.""",
+  )
+  checkpoint_id: Optional[str] = Field(
+      default=None,
+      description="""Optional. The source checkpoint id. If not specified, the default checkpoint will be used.""",
+  )
+  tuned_model_name: Optional[str] = Field(
+      default=None,
+      description="""The resource name of the Model. E.g., a model resource name with a specified version id or alias: `projects/{project}/locations/{location}/models/{model}@{version_id}` `projects/{project}/locations/{location}/models/{model}@{alias}` Or, omit the version id to use the default version: `projects/{project}/locations/{location}/models/{model}`""",
+  )
+
+
+class PreTunedModelDict(TypedDict, total=False):
+  """A pre-tuned model for continuous tuning."""
+
+  base_model: Optional[str]
+  """Output only. The name of the base model this PreTunedModel was tuned from."""
+
+  checkpoint_id: Optional[str]
+  """Optional. The source checkpoint id. If not specified, the default checkpoint will be used."""
+
+  tuned_model_name: Optional[str]
+  """The resource name of the Model. E.g., a model resource name with a specified version id or alias: `projects/{project}/locations/{location}/models/{model}@{version_id}` `projects/{project}/locations/{location}/models/{model}@{alias}` Or, omit the version id to use the default version: `projects/{project}/locations/{location}/models/{model}`"""
+
+
+PreTunedModelOrDict = Union[PreTunedModel, PreTunedModelDict]
+
+
 class SupervisedHyperParameters(_common.BaseModel):
   """Hyperparameters for SFT."""
 
   adapter_size: Optional[AdapterSize] = Field(
       default=None, description="""Optional. Adapter size for tuning."""
   )
+  batch_size: Optional[int] = Field(
+      default=None,
+      description="""Optional. Batch size for tuning. This feature is only available for open source models.""",
+  )
   epoch_count: Optional[int] = Field(
       default=None,
       description="""Optional. Number of complete passes the model makes over the entire training dataset during training.""",
   )
+  learning_rate: Optional[float] = Field(
+      default=None,
+      description="""Optional. Learning rate for tuning. Mutually exclusive with `learning_rate_multiplier`. This feature is only available for open source models.""",
+  )
   learning_rate_multiplier: Optional[float] = Field(
       default=None,
-      description="""Optional. Multiplier for adjusting the default learning rate. Mutually exclusive with `learning_rate`.""",
+      description="""Optional. Multiplier for adjusting the default learning rate. Mutually exclusive with `learning_rate`. This feature is only available for 1P models.""",
   )
 
 
@@ -8458,11 +9227,17 @@ class SupervisedHyperParametersDict(TypedDict, total=False):
   adapter_size: Optional[AdapterSize]
   """Optional. Adapter size for tuning."""
 
+  batch_size: Optional[int]
+  """Optional. Batch size for tuning. This feature is only available for open source models."""
+
   epoch_count: Optional[int]
   """Optional. Number of complete passes the model makes over the entire training dataset during training."""
 
+  learning_rate: Optional[float]
+  """Optional. Learning rate for tuning. Mutually exclusive with `learning_rate_multiplier`. This feature is only available for open source models."""
+
   learning_rate_multiplier: Optional[float]
-  """Optional. Multiplier for adjusting the default learning rate. Mutually exclusive with `learning_rate`."""
+  """Optional. Multiplier for adjusting the default learning rate. Mutually exclusive with `learning_rate`. This feature is only available for 1P models."""
 
 
 SupervisedHyperParametersOrDict = Union[
@@ -8484,6 +9259,9 @@ class SupervisedTuningSpec(_common.BaseModel):
       default=None,
       description="""Required. Training dataset used for tuning. The dataset can be specified as either a Cloud Storage path to a JSONL file or as the resource name of a Vertex Multimodal Dataset.""",
   )
+  tuning_mode: Optional[TuningMode] = Field(
+      default=None, description="""Tuning mode."""
+  )
   validation_dataset_uri: Optional[str] = Field(
       default=None,
       description="""Optional. Validation dataset used for tuning. The dataset can be specified as either a Cloud Storage path to a JSONL file or as the resource name of a Vertex Multimodal Dataset.""",
@@ -8502,6 +9280,9 @@ class SupervisedTuningSpecDict(TypedDict, total=False):
   training_dataset_uri: Optional[str]
   """Required. Training dataset used for tuning. The dataset can be specified as either a Cloud Storage path to a JSONL file or as the resource name of a Vertex Multimodal Dataset."""
 
+  tuning_mode: Optional[TuningMode]
+  """Tuning mode."""
+
   validation_dataset_uri: Optional[str]
   """Optional. Validation dataset used for tuning. The dataset can be specified as either a Cloud Storage path to a JSONL file or as the resource name of a Vertex Multimodal Dataset."""
 
@@ -8701,6 +9482,132 @@ DistillationDataStatsOrDict = Union[
 ]
 
 
+class GeminiPreferenceExampleCompletion(_common.BaseModel):
+  """Completion and its preference score."""
+
+  completion: Optional[Content] = Field(
+      default=None,
+      description="""Single turn completion for the given prompt.""",
+  )
+  score: Optional[float] = Field(
+      default=None, description="""The score for the given completion."""
+  )
+
+
+class GeminiPreferenceExampleCompletionDict(TypedDict, total=False):
+  """Completion and its preference score."""
+
+  completion: Optional[ContentDict]
+  """Single turn completion for the given prompt."""
+
+  score: Optional[float]
+  """The score for the given completion."""
+
+
+GeminiPreferenceExampleCompletionOrDict = Union[
+    GeminiPreferenceExampleCompletion, GeminiPreferenceExampleCompletionDict
+]
+
+
+class GeminiPreferenceExample(_common.BaseModel):
+  """Input example for preference optimization."""
+
+  completions: Optional[list[GeminiPreferenceExampleCompletion]] = Field(
+      default=None, description="""List of completions for a given prompt."""
+  )
+  contents: Optional[list[Content]] = Field(
+      default=None,
+      description="""Multi-turn contents that represents the Prompt.""",
+  )
+
+
+class GeminiPreferenceExampleDict(TypedDict, total=False):
+  """Input example for preference optimization."""
+
+  completions: Optional[list[GeminiPreferenceExampleCompletionDict]]
+  """List of completions for a given prompt."""
+
+  contents: Optional[list[ContentDict]]
+  """Multi-turn contents that represents the Prompt."""
+
+
+GeminiPreferenceExampleOrDict = Union[
+    GeminiPreferenceExample, GeminiPreferenceExampleDict
+]
+
+
+class PreferenceOptimizationDataStats(_common.BaseModel):
+  """Statistics computed for datasets used for preference optimization."""
+
+  score_variance_per_example_distribution: Optional[DatasetDistribution] = (
+      Field(
+          default=None,
+          description="""Output only. Dataset distributions for scores variance per example.""",
+      )
+  )
+  scores_distribution: Optional[DatasetDistribution] = Field(
+      default=None,
+      description="""Output only. Dataset distributions for scores.""",
+  )
+  total_billable_token_count: Optional[int] = Field(
+      default=None,
+      description="""Output only. Number of billable tokens in the tuning dataset.""",
+  )
+  tuning_dataset_example_count: Optional[int] = Field(
+      default=None,
+      description="""Output only. Number of examples in the tuning dataset.""",
+  )
+  tuning_step_count: Optional[int] = Field(
+      default=None,
+      description="""Output only. Number of tuning steps for this Tuning Job.""",
+  )
+  user_dataset_examples: Optional[list[GeminiPreferenceExample]] = Field(
+      default=None,
+      description="""Output only. Sample user examples in the training dataset.""",
+  )
+  user_input_token_distribution: Optional[DatasetDistribution] = Field(
+      default=None,
+      description="""Output only. Dataset distributions for the user input tokens.""",
+  )
+  user_output_token_distribution: Optional[DatasetDistribution] = Field(
+      default=None,
+      description="""Output only. Dataset distributions for the user output tokens.""",
+  )
+
+
+class PreferenceOptimizationDataStatsDict(TypedDict, total=False):
+  """Statistics computed for datasets used for preference optimization."""
+
+  score_variance_per_example_distribution: Optional[DatasetDistributionDict]
+  """Output only. Dataset distributions for scores variance per example."""
+
+  scores_distribution: Optional[DatasetDistributionDict]
+  """Output only. Dataset distributions for scores."""
+
+  total_billable_token_count: Optional[int]
+  """Output only. Number of billable tokens in the tuning dataset."""
+
+  tuning_dataset_example_count: Optional[int]
+  """Output only. Number of examples in the tuning dataset."""
+
+  tuning_step_count: Optional[int]
+  """Output only. Number of tuning steps for this Tuning Job."""
+
+  user_dataset_examples: Optional[list[GeminiPreferenceExampleDict]]
+  """Output only. Sample user examples in the training dataset."""
+
+  user_input_token_distribution: Optional[DatasetDistributionDict]
+  """Output only. Dataset distributions for the user input tokens."""
+
+  user_output_token_distribution: Optional[DatasetDistributionDict]
+  """Output only. Dataset distributions for the user output tokens."""
+
+
+PreferenceOptimizationDataStatsOrDict = Union[
+    PreferenceOptimizationDataStats, PreferenceOptimizationDataStatsDict
+]
+
+
 class SupervisedTuningDatasetDistributionDatasetBucket(_common.BaseModel):
   """Dataset bucket used to create a histogram for the distribution given a population of values."""
 
@@ -8932,6 +9839,12 @@ class TuningDataStats(_common.BaseModel):
   distillation_data_stats: Optional[DistillationDataStats] = Field(
       default=None, description="""Output only. Statistics for distillation."""
   )
+  preference_optimization_data_stats: Optional[
+      PreferenceOptimizationDataStats
+  ] = Field(
+      default=None,
+      description="""Output only. Statistics for preference optimization.""",
+  )
   supervised_tuning_data_stats: Optional[SupervisedTuningDataStats] = Field(
       default=None, description="""The SFT Tuning data stats."""
   )
@@ -8943,6 +9856,11 @@ class TuningDataStatsDict(TypedDict, total=False):
   distillation_data_stats: Optional[DistillationDataStatsDict]
   """Output only. Statistics for distillation."""
 
+  preference_optimization_data_stats: Optional[
+      PreferenceOptimizationDataStatsDict
+  ]
+  """Output only. Statistics for preference optimization."""
+
   supervised_tuning_data_stats: Optional[SupervisedTuningDataStatsDict]
   """The SFT Tuning data stats."""
 
@@ -9004,101 +9922,6 @@ PartnerModelTuningSpecOrDict = Union[
 ]
 
 
-class DistillationHyperParameters(_common.BaseModel):
-  """Hyperparameters for Distillation."""
-
-  adapter_size: Optional[AdapterSize] = Field(
-      default=None, description="""Optional. Adapter size for distillation."""
-  )
-  epoch_count: Optional[int] = Field(
-      default=None,
-      description="""Optional. Number of complete passes the model makes over the entire training dataset during training.""",
-  )
-  learning_rate_multiplier: Optional[float] = Field(
-      default=None,
-      description="""Optional. Multiplier for adjusting the default learning rate.""",
-  )
-
-
-class DistillationHyperParametersDict(TypedDict, total=False):
-  """Hyperparameters for Distillation."""
-
-  adapter_size: Optional[AdapterSize]
-  """Optional. Adapter size for distillation."""
-
-  epoch_count: Optional[int]
-  """Optional. Number of complete passes the model makes over the entire training dataset during training."""
-
-  learning_rate_multiplier: Optional[float]
-  """Optional. Multiplier for adjusting the default learning rate."""
-
-
-DistillationHyperParametersOrDict = Union[
-    DistillationHyperParameters, DistillationHyperParametersDict
-]
-
-
-class DistillationSpec(_common.BaseModel):
-  """Tuning Spec for Distillation."""
-
-  base_teacher_model: Optional[str] = Field(
-      default=None,
-      description="""The base teacher model that is being distilled. See [Supported models](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/tuning#supported_models).""",
-  )
-  hyper_parameters: Optional[DistillationHyperParameters] = Field(
-      default=None,
-      description="""Optional. Hyperparameters for Distillation.""",
-  )
-  pipeline_root_directory: Optional[str] = Field(
-      default=None,
-      description="""Deprecated. A path in a Cloud Storage bucket, which will be treated as the root output directory of the distillation pipeline. It is used by the system to generate the paths of output artifacts.""",
-  )
-  student_model: Optional[str] = Field(
-      default=None,
-      description="""The student model that is being tuned, e.g., "google/gemma-2b-1.1-it". Deprecated. Use base_model instead.""",
-  )
-  training_dataset_uri: Optional[str] = Field(
-      default=None,
-      description="""Deprecated. Cloud Storage path to file containing training dataset for tuning. The dataset must be formatted as a JSONL file.""",
-  )
-  tuned_teacher_model_source: Optional[str] = Field(
-      default=None,
-      description="""The resource name of the Tuned teacher model. Format: `projects/{project}/locations/{location}/models/{model}`.""",
-  )
-  validation_dataset_uri: Optional[str] = Field(
-      default=None,
-      description="""Optional. Cloud Storage path to file containing validation dataset for tuning. The dataset must be formatted as a JSONL file.""",
-  )
-
-
-class DistillationSpecDict(TypedDict, total=False):
-  """Tuning Spec for Distillation."""
-
-  base_teacher_model: Optional[str]
-  """The base teacher model that is being distilled. See [Supported models](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/tuning#supported_models)."""
-
-  hyper_parameters: Optional[DistillationHyperParametersDict]
-  """Optional. Hyperparameters for Distillation."""
-
-  pipeline_root_directory: Optional[str]
-  """Deprecated. A path in a Cloud Storage bucket, which will be treated as the root output directory of the distillation pipeline. It is used by the system to generate the paths of output artifacts."""
-
-  student_model: Optional[str]
-  """The student model that is being tuned, e.g., "google/gemma-2b-1.1-it". Deprecated. Use base_model instead."""
-
-  training_dataset_uri: Optional[str]
-  """Deprecated. Cloud Storage path to file containing training dataset for tuning. The dataset must be formatted as a JSONL file."""
-
-  tuned_teacher_model_source: Optional[str]
-  """The resource name of the Tuned teacher model. Format: `projects/{project}/locations/{location}/models/{model}`."""
-
-  validation_dataset_uri: Optional[str]
-  """Optional. Cloud Storage path to file containing validation dataset for tuning. The dataset must be formatted as a JSONL file."""
-
-
-DistillationSpecOrDict = Union[DistillationSpec, DistillationSpecDict]
-
-
 class TuningJob(_common.BaseModel):
   """A tuning job."""
 
@@ -9145,6 +9968,9 @@ class TuningJob(_common.BaseModel):
       default=None,
       description="""Output only. The tuned model resources associated with this TuningJob.""",
   )
+  pre_tuned_model: Optional[PreTunedModel] = Field(
+      default=None, description="""The pre-tuned model for continuous tuning."""
+  )
   supervised_tuning_spec: Optional[SupervisedTuningSpec] = Field(
       default=None, description="""Tuning Spec for Supervised Fine Tuning."""
   )
@@ -9160,8 +9986,12 @@ class TuningJob(_common.BaseModel):
       default=None,
       description="""Tuning Spec for open sourced and third party Partner models.""",
   )
-  distillation_spec: Optional[DistillationSpec] = Field(
-      default=None, description="""Tuning Spec for Distillation."""
+  evaluation_config: Optional[EvaluationConfig] = Field(
+      default=None, description=""""""
+  )
+  custom_base_model: Optional[str] = Field(
+      default=None,
+      description="""Optional. The user-provided path to custom model weights. Set this field to tune a custom model. The path must be a Cloud Storage directory that contains the model weights in .safetensors format along with associated model metadata files. If this field is set, the base_model field must still be set to indicate which base model the custom model is derived from. This feature is only available for open source models.""",
   )
   experiment: Optional[str] = Field(
       default=None,
@@ -9171,16 +10001,14 @@ class TuningJob(_common.BaseModel):
       default=None,
       description="""Optional. The labels with user-defined metadata to organize TuningJob and generated resources such as Model and Endpoint. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels.""",
   )
+  output_uri: Optional[str] = Field(
+      default=None,
+      description="""Optional. Cloud Storage path to the directory where tuning job outputs are written to. This field is only available and required for open source models.""",
+  )
   pipeline_job: Optional[str] = Field(
       default=None,
       description="""Output only. The resource name of the PipelineJob associated with the TuningJob. Format: `projects/{project}/locations/{location}/pipelineJobs/{pipeline_job}`.""",
   )
-  satisfies_pzi: Optional[bool] = Field(
-      default=None, description="""Output only. Reserved for future use."""
-  )
-  satisfies_pzs: Optional[bool] = Field(
-      default=None, description="""Output only. Reserved for future use."""
-  )
   service_account: Optional[str] = Field(
       default=None,
       description="""The service account that the tuningJob workload runs as. If not specified, the Vertex AI Secure Fine-Tuned Service Agent in the project will be used. See https://cloud.google.com/iam/docs/service-agents#vertex-ai-secure-fine-tuning-service-agent Users starting the pipeline must have the `iam.serviceAccounts.actAs` permission on this service account.""",
@@ -9237,6 +10065,9 @@ class TuningJobDict(TypedDict, total=False):
   tuned_model: Optional[TunedModelDict]
   """Output only. The tuned model resources associated with this TuningJob."""
 
+  pre_tuned_model: Optional[PreTunedModelDict]
+  """The pre-tuned model for continuous tuning."""
+
   supervised_tuning_spec: Optional[SupervisedTuningSpecDict]
   """Tuning Spec for Supervised Fine Tuning."""
 
@@ -9249,8 +10080,11 @@ class TuningJobDict(TypedDict, total=False):
   partner_model_tuning_spec: Optional[PartnerModelTuningSpecDict]
   """Tuning Spec for open sourced and third party Partner models."""
 
-  distillation_spec: Optional[DistillationSpecDict]
-  """Tuning Spec for Distillation."""
+  evaluation_config: Optional[EvaluationConfigDict]
+  """"""
+
+  custom_base_model: Optional[str]
+  """Optional. The user-provided path to custom model weights. Set this field to tune a custom model. The path must be a Cloud Storage directory that contains the model weights in .safetensors format along with associated model metadata files. If this field is set, the base_model field must still be set to indicate which base model the custom model is derived from. This feature is only available for open source models."""
 
   experiment: Optional[str]
   """Output only. The Experiment associated with this TuningJob."""
@@ -9258,15 +10092,12 @@ class TuningJobDict(TypedDict, total=False):
   labels: Optional[dict[str, str]]
   """Optional. The labels with user-defined metadata to organize TuningJob and generated resources such as Model and Endpoint. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels."""
 
+  output_uri: Optional[str]
+  """Optional. Cloud Storage path to the directory where tuning job outputs are written to. This field is only available and required for open source models."""
+
   pipeline_job: Optional[str]
   """Output only. The resource name of the PipelineJob associated with the TuningJob. Format: `projects/{project}/locations/{location}/pipelineJobs/{pipeline_job}`."""
 
-  satisfies_pzi: Optional[bool]
-  """Output only. Reserved for future use."""
-
-  satisfies_pzs: Optional[bool]
-  """Output only. Reserved for future use."""
-
   service_account: Optional[str]
   """The service account that the tuningJob workload runs as. If not specified, the Vertex AI Secure Fine-Tuned Service Agent in the project will be used. See https://cloud.google.com/iam/docs/service-agents#vertex-ai-secure-fine-tuning-service-agent Users starting the pipeline must have the `iam.serviceAccounts.actAs` permission on this service account."""
 
@@ -9472,6 +10303,10 @@ class CreateTuningJobConfig(_common.BaseModel):
       default=None,
       description="""If set to true, disable intermediate checkpoints for SFT and only the last checkpoint will be exported. Otherwise, enable intermediate checkpoints for SFT.""",
   )
+  pre_tuned_model_checkpoint_id: Optional[str] = Field(
+      default=None,
+      description="""The optional checkpoint id of the pre-tuned model to use for tuning, if applicable.""",
+  )
   adapter_size: Optional[AdapterSize] = Field(
       default=None, description="""Adapter size for tuning."""
   )
@@ -9483,6 +10318,9 @@ class CreateTuningJobConfig(_common.BaseModel):
       default=None,
       description="""The learning rate hyperparameter for tuning. If not set, a default of 0.001 or 0.0002 will be calculated based on the number of training examples.""",
   )
+  evaluation_config: Optional[EvaluationConfig] = Field(
+      default=None, description="""Evaluation config for the tuning job."""
+  )
 
 
 class CreateTuningJobConfigDict(TypedDict, total=False):
@@ -9509,6 +10347,9 @@ class CreateTuningJobConfigDict(TypedDict, total=False):
   export_last_checkpoint_only: Optional[bool]
   """If set to true, disable intermediate checkpoints for SFT and only the last checkpoint will be exported. Otherwise, enable intermediate checkpoints for SFT."""
 
+  pre_tuned_model_checkpoint_id: Optional[str]
+  """The optional checkpoint id of the pre-tuned model to use for tuning, if applicable."""
+
   adapter_size: Optional[AdapterSize]
   """Adapter size for tuning."""
 
@@ -9518,18 +10359,24 @@ class CreateTuningJobConfigDict(TypedDict, total=False):
   learning_rate: Optional[float]
   """The learning rate hyperparameter for tuning. If not set, a default of 0.001 or 0.0002 will be calculated based on the number of training examples."""
 
+  evaluation_config: Optional[EvaluationConfigDict]
+  """Evaluation config for the tuning job."""
+
 
 CreateTuningJobConfigOrDict = Union[
     CreateTuningJobConfig, CreateTuningJobConfigDict
 ]
 
 
-class _CreateTuningJobParameters(_common.BaseModel):
+class _CreateTuningJobParametersPrivate(_common.BaseModel):
   """Supervised fine-tuning job creation parameters - optional fields."""
 
   base_model: Optional[str] = Field(
       default=None,
-      description="""The base model that is being tuned, e.g., "gemini-1.0-pro-002".""",
+      description="""The base model that is being tuned, e.g., "gemini-2.5-flash".""",
+  )
+  pre_tuned_model: Optional[PreTunedModel] = Field(
+      default=None, description="""The PreTunedModel that is being tuned."""
   )
   training_dataset: Optional[TuningDataset] = Field(
       default=None,
@@ -9540,11 +10387,14 @@ class _CreateTuningJobParameters(_common.BaseModel):
   )
 
 
-class _CreateTuningJobParametersDict(TypedDict, total=False):
+class _CreateTuningJobParametersPrivateDict(TypedDict, total=False):
   """Supervised fine-tuning job creation parameters - optional fields."""
 
   base_model: Optional[str]
-  """The base model that is being tuned, e.g., "gemini-1.0-pro-002"."""
+  """The base model that is being tuned, e.g., "gemini-2.5-flash"."""
+
+  pre_tuned_model: Optional[PreTunedModelDict]
+  """The PreTunedModel that is being tuned."""
 
   training_dataset: Optional[TuningDatasetDict]
   """Cloud Storage path to file containing training dataset for tuning. The dataset must be formatted as a JSONL file."""
@@ -9553,8 +10403,8 @@ class _CreateTuningJobParametersDict(TypedDict, total=False):
   """Configuration for the tuning job."""
 
 
-_CreateTuningJobParametersOrDict = Union[
-    _CreateTuningJobParameters, _CreateTuningJobParametersDict
+_CreateTuningJobParametersPrivateOrDict = Union[
+    _CreateTuningJobParametersPrivate, _CreateTuningJobParametersPrivateDict
 ]
 
 
@@ -12342,95 +13192,6 @@ class LiveServerMessageDict(TypedDict, total=False):
 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.
 
@@ -12557,16 +13318,105 @@ class ProactivityConfig(_common.BaseModel):
   )
 
 
-class ProactivityConfigDict(TypedDict, total=False):
-  """Config for proactivity features."""
+class ProactivityConfigDict(TypedDict, total=False):
+  """Config for proactivity features."""
+
+  proactive_audio: Optional[bool]
+  """If enabled, the model can reject responding to the last prompt. For
+        example, this allows the model to ignore out of context speech or to stay
+        silent if the user did not make a request, yet."""
+
+
+ProactivityConfigOrDict = Union[ProactivityConfig, ProactivityConfigDict]
+
+
+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."""
 
-  proactive_audio: Optional[bool]
-  """If enabled, the model can reject responding to the last prompt. For
-        example, this allows the model to ignore out of context speech or to stay
-        silent if the user did not make a request, yet."""
+  turn_coverage: Optional[TurnCoverage]
+  """Defines which input is included in the user's turn."""
 
 
-ProactivityConfigOrDict = Union[ProactivityConfig, ProactivityConfigDict]
+RealtimeInputConfigOrDict = Union[RealtimeInputConfig, RealtimeInputConfigDict]
 
 
 class LiveClientSetup(_common.BaseModel):
@@ -12881,6 +13731,44 @@ LiveClientRealtimeInputOrDict = Union[
 ]
 
 
+class LiveClientToolResponse(_common.BaseModel):
+  """Client generated response to a `ToolCall` received from the server.
+
+  Individual `FunctionResponse` objects are matched to the respective
+  `FunctionCall` objects by the `id` field.
+
+  Note that in the unary and server-streaming GenerateContent APIs function
+  calling happens by exchanging the `Content` parts, while in the bidi
+  GenerateContent APIs function calling happens over this dedicated set of
+  messages.
+  """
+
+  function_responses: Optional[list[FunctionResponse]] = Field(
+      default=None, description="""The response to the function calls."""
+  )
+
+
+class LiveClientToolResponseDict(TypedDict, total=False):
+  """Client generated response to a `ToolCall` received from the server.
+
+  Individual `FunctionResponse` objects are matched to the respective
+  `FunctionCall` objects by the `id` field.
+
+  Note that in the unary and server-streaming GenerateContent APIs function
+  calling happens by exchanging the `Content` parts, while in the bidi
+  GenerateContent APIs function calling happens over this dedicated set of
+  messages.
+  """
+
+  function_responses: Optional[list[FunctionResponseDict]]
+  """The response to the function calls."""
+
+
+LiveClientToolResponseOrDict = Union[
+    LiveClientToolResponse, LiveClientToolResponseDict
+]
+
+
 if _is_pillow_image_imported:
   BlobImageUnion = Union[PIL_Image, Blob]
 else:
@@ -12966,44 +13854,6 @@ LiveSendRealtimeInputParametersOrDict = Union[
 ]
 
 
-class LiveClientToolResponse(_common.BaseModel):
-  """Client generated response to a `ToolCall` received from the server.
-
-  Individual `FunctionResponse` objects are matched to the respective
-  `FunctionCall` objects by the `id` field.
-
-  Note that in the unary and server-streaming GenerateContent APIs function
-  calling happens by exchanging the `Content` parts, while in the bidi
-  GenerateContent APIs function calling happens over this dedicated set of
-  messages.
-  """
-
-  function_responses: Optional[list[FunctionResponse]] = Field(
-      default=None, description="""The response to the function calls."""
-  )
-
-
-class LiveClientToolResponseDict(TypedDict, total=False):
-  """Client generated response to a `ToolCall` received from the server.
-
-  Individual `FunctionResponse` objects are matched to the respective
-  `FunctionCall` objects by the `id` field.
-
-  Note that in the unary and server-streaming GenerateContent APIs function
-  calling happens by exchanging the `Content` parts, while in the bidi
-  GenerateContent APIs function calling happens over this dedicated set of
-  messages.
-  """
-
-  function_responses: Optional[list[FunctionResponseDict]]
-  """The response to the function calls."""
-
-
-LiveClientToolResponseOrDict = Union[
-    LiveClientToolResponse, LiveClientToolResponseDict
-]
-
-
 class LiveClientMessage(_common.BaseModel):
   """Messages sent by the client in the API call."""
 
@@ -13885,3 +14735,250 @@ class CreateAuthTokenParametersDict(TypedDict, total=False):
 CreateAuthTokenParametersOrDict = Union[
     CreateAuthTokenParameters, CreateAuthTokenParametersDict
 ]
+
+
+class CreateTuningJobParameters(_common.BaseModel):
+  """Supervised fine-tuning job creation parameters - optional fields."""
+
+  base_model: Optional[str] = Field(
+      default=None,
+      description="""The base model that is being tuned, e.g., "gemini-2.5-flash".""",
+  )
+  training_dataset: Optional[TuningDataset] = Field(
+      default=None,
+      description="""Cloud Storage path to file containing training dataset for tuning. The dataset must be formatted as a JSONL file.""",
+  )
+  config: Optional[CreateTuningJobConfig] = Field(
+      default=None, description="""Configuration for the tuning job."""
+  )
+
+
+class CreateTuningJobParametersDict(TypedDict, total=False):
+  """Supervised fine-tuning job creation parameters - optional fields."""
+
+  base_model: Optional[str]
+  """The base model that is being tuned, e.g., "gemini-2.5-flash"."""
+
+  training_dataset: Optional[TuningDatasetDict]
+  """Cloud Storage path to file containing training dataset for tuning. The dataset must be formatted as a JSONL file."""
+
+  config: Optional[CreateTuningJobConfigDict]
+  """Configuration for the tuning job."""
+
+
+CreateTuningJobParametersOrDict = Union[
+    CreateTuningJobParameters, CreateTuningJobParametersDict
+]
+
+
+class UserContent(Content):
+  """UserContent facilitates the creation of a Content object with a user role.
+
+  Example usages:
+
+
+  - Create a user Content object with a string:
+    user_content = UserContent("Why is the sky blue?")
+  - Create a user Content object with a file data Part object:
+    user_content = UserContent(Part.from_uri(file_uril="gs://bucket/file.txt",
+    mime_type="text/plain"))
+  - Create a user Content object with byte data Part object:
+    user_content = UserContent(Part.from_bytes(data=b"Hello, World!",
+    mime_type="text/plain"))
+
+    You can create a user Content object using other classmethods in the Part
+    class as well.
+    You can also create a user Content using a list of Part objects or strings.
+  """
+
+  role: Literal['user'] = Field(default='user', init=False, frozen=True)
+  parts: list[Part] = Field()
+
+  def __init__(
+      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
+  ):
+    from . import _transformers as t
+
+    super().__init__(parts=t.t_parts(parts=parts))
+
+
+class ModelContent(Content):
+  """ModelContent facilitates the creation of a Content object with a model role.
+
+  Example usages:
+
+  - Create a model Content object with a string:
+    model_content = ModelContent("Why is the sky blue?")
+  - Create a model Content object with a file data Part object:
+    model_content = ModelContent(Part.from_uri(file_uril="gs://bucket/file.txt",
+    mime_type="text/plain"))
+  - Create a model Content object with byte data Part object:
+    model_content = ModelContent(Part.from_bytes(data=b"Hello, World!",
+    mime_type="text/plain"))
+
+    You can create a model Content object using other classmethods in the Part
+    class as well.
+    You can also create a model Content using a list of Part objects or strings.
+  """
+
+  role: Literal['model'] = Field(default='model', init=False, frozen=True)
+  parts: list[Part] = Field()
+
+  def __init__(
+      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
+  ):
+    from . import _transformers as t
+
+    super().__init__(parts=t.t_parts(parts=parts))
+
+
+class CustomOutputFormatConfig(_common.BaseModel):
+  """Config for custom output format."""
+
+  return_raw_output: Optional[bool] = Field(
+      default=None, description="""Optional. Whether to return raw output."""
+  )
+
+
+class CustomOutputFormatConfigDict(TypedDict, total=False):
+  """Config for custom output format."""
+
+  return_raw_output: Optional[bool]
+  """Optional. Whether to return raw output."""
+
+
+CustomOutputFormatConfigOrDict = Union[
+    CustomOutputFormatConfig, CustomOutputFormatConfigDict
+]
+
+
+class BleuSpec(_common.BaseModel):
+  """Spec for bleu metric."""
+
+  use_effective_order: Optional[bool] = Field(
+      default=None,
+      description="""Optional. Whether to use_effective_order to compute bleu score.""",
+  )
+
+
+class BleuSpecDict(TypedDict, total=False):
+  """Spec for bleu metric."""
+
+  use_effective_order: Optional[bool]
+  """Optional. Whether to use_effective_order to compute bleu score."""
+
+
+BleuSpecOrDict = Union[BleuSpec, BleuSpecDict]
+
+
+class PairwiseMetricSpec(_common.BaseModel):
+  """Spec for pairwise metric."""
+
+  metric_prompt_template: Optional[str] = Field(
+      default=None,
+      description="""Required. Metric prompt template for pairwise metric.""",
+  )
+  baseline_response_field_name: Optional[str] = Field(
+      default=None,
+      description="""Optional. The field name of the baseline response.""",
+  )
+  candidate_response_field_name: Optional[str] = Field(
+      default=None,
+      description="""Optional. The field name of the candidate response.""",
+  )
+  custom_output_format_config: Optional[CustomOutputFormatConfig] = Field(
+      default=None,
+      description="""Optional. CustomOutputFormatConfig allows customization of metric output. When this config is set, the default output is replaced with the raw output string. If a custom format is chosen, the `pairwise_choice` and `explanation` fields in the corresponding metric result will be empty.""",
+  )
+  system_instruction: Optional[str] = Field(
+      default=None,
+      description="""Optional. System instructions for pairwise metric.""",
+  )
+
+
+class PairwiseMetricSpecDict(TypedDict, total=False):
+  """Spec for pairwise metric."""
+
+  metric_prompt_template: Optional[str]
+  """Required. Metric prompt template for pairwise metric."""
+
+  baseline_response_field_name: Optional[str]
+  """Optional. The field name of the baseline response."""
+
+  candidate_response_field_name: Optional[str]
+  """Optional. The field name of the candidate response."""
+
+  custom_output_format_config: Optional[CustomOutputFormatConfigDict]
+  """Optional. CustomOutputFormatConfig allows customization of metric output. When this config is set, the default output is replaced with the raw output string. If a custom format is chosen, the `pairwise_choice` and `explanation` fields in the corresponding metric result will be empty."""
+
+  system_instruction: Optional[str]
+  """Optional. System instructions for pairwise metric."""
+
+
+PairwiseMetricSpecOrDict = Union[PairwiseMetricSpec, PairwiseMetricSpecDict]
+
+
+class PointwiseMetricSpec(_common.BaseModel):
+  """Spec for pointwise metric."""
+
+  metric_prompt_template: Optional[str] = Field(
+      default=None,
+      description="""Required. Metric prompt template for pointwise metric.""",
+  )
+  custom_output_format_config: Optional[CustomOutputFormatConfig] = Field(
+      default=None,
+      description="""Optional. CustomOutputFormatConfig allows customization of metric output. By default, metrics return a score and explanation. When this config is set, the default output is replaced with either: - The raw output string. - A parsed output based on a user-defined schema. If a custom format is chosen, the `score` and `explanation` fields in the corresponding metric result will be empty.""",
+  )
+  system_instruction: Optional[str] = Field(
+      default=None,
+      description="""Optional. System instructions for pointwise metric.""",
+  )
+
+
+class PointwiseMetricSpecDict(TypedDict, total=False):
+  """Spec for pointwise metric."""
+
+  metric_prompt_template: Optional[str]
+  """Required. Metric prompt template for pointwise metric."""
+
+  custom_output_format_config: Optional[CustomOutputFormatConfigDict]
+  """Optional. CustomOutputFormatConfig allows customization of metric output. By default, metrics return a score and explanation. When this config is set, the default output is replaced with either: - The raw output string. - A parsed output based on a user-defined schema. If a custom format is chosen, the `score` and `explanation` fields in the corresponding metric result will be empty."""
+
+  system_instruction: Optional[str]
+  """Optional. System instructions for pointwise metric."""
+
+
+PointwiseMetricSpecOrDict = Union[PointwiseMetricSpec, PointwiseMetricSpecDict]
+
+
+class RougeSpec(_common.BaseModel):
+  """Spec for rouge metric."""
+
+  rouge_type: Optional[str] = Field(
+      default=None,
+      description="""Optional. Supported rouge types are rougen[1-9], rougeL, and rougeLsum.""",
+  )
+  split_summaries: Optional[bool] = Field(
+      default=None,
+      description="""Optional. Whether to split summaries while using rougeLsum.""",
+  )
+  use_stemmer: Optional[bool] = Field(
+      default=None,
+      description="""Optional. Whether to use stemmer to compute rouge score.""",
+  )
+
+
+class RougeSpecDict(TypedDict, total=False):
+  """Spec for rouge metric."""
+
+  rouge_type: Optional[str]
+  """Optional. Supported rouge types are rougen[1-9], rougeL, and rougeLsum."""
+
+  split_summaries: Optional[bool]
+  """Optional. Whether to split summaries while using rougeLsum."""
+
+  use_stemmer: Optional[bool]
+  """Optional. Whether to use stemmer to compute rouge score."""
+
+
+RougeSpecOrDict = Union[RougeSpec, RougeSpecDict]