google-genai 1.12.1__py3-none-any.whl → 1.13.0__py3-none-any.whl

google/genai/types.py

@@ -76,18 +76,6 @@ class Language(_common.CaseInSensitiveEnum):
   PYTHON = 'PYTHON'
 
 
-class Type(_common.CaseInSensitiveEnum):
-  """Optional. The type of the data."""
-
-  TYPE_UNSPECIFIED = 'TYPE_UNSPECIFIED'
-  STRING = 'STRING'
-  NUMBER = 'NUMBER'
-  INTEGER = 'INTEGER'
-  BOOLEAN = 'BOOLEAN'
-  ARRAY = 'ARRAY'
-  OBJECT = 'OBJECT'
-
-
 class HarmCategory(_common.CaseInSensitiveEnum):
   """Required. Harm category."""
 
@@ -129,6 +117,18 @@ class Mode(_common.CaseInSensitiveEnum):
   MODE_DYNAMIC = 'MODE_DYNAMIC'
 
 
+class Type(_common.CaseInSensitiveEnum):
+  """Optional. The type of the data."""
+
+  TYPE_UNSPECIFIED = 'TYPE_UNSPECIFIED'
+  STRING = 'STRING'
+  NUMBER = 'NUMBER'
+  INTEGER = 'INTEGER'
+  BOOLEAN = 'BOOLEAN'
+  ARRAY = 'ARRAY'
+  OBJECT = 'OBJECT'
+
+
 class FinishReason(_common.CaseInSensitiveEnum):
   """Output only. The reason why the model stopped generating tokens.
 
@@ -881,219 +881,653 @@ class HttpOptionsDict(TypedDict, total=False):
 HttpOptionsOrDict = Union[HttpOptions, HttpOptionsDict]
 
 
-class JSONSchemaType(Enum):
-  """The type of the data supported by JSON Schema.
+class ModelSelectionConfig(_common.BaseModel):
+  """Config for model selection."""
 
-  The values of the enums are lower case strings, while the values of the enums
-  for the Type class are upper case strings.
-  """
+  feature_selection_preference: Optional[FeatureSelectionPreference] = Field(
+      default=None, description="""Options for feature selection preference."""
+  )
 
-  NULL = 'null'
-  BOOLEAN = 'boolean'
-  OBJECT = 'object'
-  ARRAY = 'array'
-  NUMBER = 'number'
-  INTEGER = 'integer'
-  STRING = 'string'
 
+class ModelSelectionConfigDict(TypedDict, total=False):
+  """Config for model selection."""
 
-class JSONSchema(pydantic.BaseModel):
-  """A subset of JSON Schema according to 2020-12 JSON Schema draft.
+  feature_selection_preference: Optional[FeatureSelectionPreference]
+  """Options for feature selection preference."""
 
-  Represents a subset of a JSON Schema object that is used by the Gemini model.
-  The difference between this class and the Schema class is that this class is
-  compatible with OpenAPI 3.1 schema objects. And the Schema class is used to
-  make API call to Gemini model.
-  """
 
-  type: Optional[Union[JSONSchemaType, list[JSONSchemaType]]] = Field(
+ModelSelectionConfigOrDict = Union[
+    ModelSelectionConfig, ModelSelectionConfigDict
+]
+
+
+class SafetySetting(_common.BaseModel):
+  """Safety settings."""
+
+  method: Optional[HarmBlockMethod] = Field(
       default=None,
-      description="""Validation succeeds if the type of the instance matches the type represented by the given type, or matches at least one of the given types.""",
+      description="""Determines if the harm block method uses probability or probability
+      and severity scores.""",
   )
-  format: Optional[str] = Field(
-      default=None,
-      description='Define semantic information about a string instance.',
+  category: Optional[HarmCategory] = Field(
+      default=None, description="""Required. Harm category."""
   )
-  title: Optional[str] = Field(
+  threshold: Optional[HarmBlockThreshold] = Field(
+      default=None, description="""Required. The harm block threshold."""
+  )
+
+
+class SafetySettingDict(TypedDict, total=False):
+  """Safety settings."""
+
+  method: Optional[HarmBlockMethod]
+  """Determines if the harm block method uses probability or probability
+      and severity scores."""
+
+  category: Optional[HarmCategory]
+  """Required. Harm category."""
+
+  threshold: Optional[HarmBlockThreshold]
+  """Required. The harm block threshold."""
+
+
+SafetySettingOrDict = Union[SafetySetting, SafetySettingDict]
+
+
+class GoogleSearch(_common.BaseModel):
+  """Tool to support Google Search in Model. Powered by Google."""
+
+  pass
+
+
+class GoogleSearchDict(TypedDict, total=False):
+  """Tool to support Google Search in Model. Powered by Google."""
+
+  pass
+
+
+GoogleSearchOrDict = Union[GoogleSearch, GoogleSearchDict]
+
+
+class DynamicRetrievalConfig(_common.BaseModel):
+  """Describes the options to customize dynamic retrieval."""
+
+  mode: Optional[DynamicRetrievalConfigMode] = Field(
       default=None,
-      description=(
-          'A preferably short description about the purpose of the instance'
-          ' described by the schema.'
-      ),
+      description="""The mode of the predictor to be used in dynamic retrieval.""",
   )
-  description: Optional[str] = Field(
+  dynamic_threshold: Optional[float] = Field(
       default=None,
-      description=(
-          'An explanation about the purpose of the instance described by the'
-          ' schema.'
-      ),
+      description="""Optional. The threshold to be used in dynamic retrieval. If not set, a system default value is used.""",
   )
-  default: Optional[Any] = Field(
+
+
+class DynamicRetrievalConfigDict(TypedDict, total=False):
+  """Describes the options to customize dynamic retrieval."""
+
+  mode: Optional[DynamicRetrievalConfigMode]
+  """The mode of the predictor to be used in dynamic retrieval."""
+
+  dynamic_threshold: Optional[float]
+  """Optional. The threshold to be used in dynamic retrieval. If not set, a system default value is used."""
+
+
+DynamicRetrievalConfigOrDict = Union[
+    DynamicRetrievalConfig, DynamicRetrievalConfigDict
+]
+
+
+class GoogleSearchRetrieval(_common.BaseModel):
+  """Tool to retrieve public web data for grounding, powered by Google."""
+
+  dynamic_retrieval_config: Optional[DynamicRetrievalConfig] = Field(
       default=None,
-      description=(
-          'This keyword can be used to supply a default JSON value associated'
-          ' with a particular schema.'
-      ),
+      description="""Specifies the dynamic retrieval configuration for the given source.""",
   )
-  items: Optional['JSONSchema'] = Field(
+
+
+class GoogleSearchRetrievalDict(TypedDict, total=False):
+  """Tool to retrieve public web data for grounding, powered by Google."""
+
+  dynamic_retrieval_config: Optional[DynamicRetrievalConfigDict]
+  """Specifies the dynamic retrieval configuration for the given source."""
+
+
+GoogleSearchRetrievalOrDict = Union[
+    GoogleSearchRetrieval, GoogleSearchRetrievalDict
+]
+
+
+class VertexAISearch(_common.BaseModel):
+  """Retrieve from Vertex AI Search datastore or engine for grounding.
+
+  datastore and engine are mutually exclusive. See
+  https://cloud.google.com/products/agent-builder
+  """
+
+  datastore: Optional[str] = Field(
       default=None,
-      description=(
-          'Validation succeeds if each element of the instance not covered by'
-          ' prefixItems validates against this schema.'
-      ),
+      description="""Optional. Fully-qualified Vertex AI Search data store resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}`""",
   )
-  min_items: Optional[int] = Field(
+  engine: Optional[str] = Field(
       default=None,
-      description=(
-          'An array instance is valid if its size is greater than, or equal to,'
-          ' the value of this keyword.'
-      ),
+      description="""Optional. Fully-qualified Vertex AI Search engine resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}`""",
   )
-  max_items: Optional[int] = Field(
+
+
+class VertexAISearchDict(TypedDict, total=False):
+  """Retrieve from Vertex AI Search datastore or engine for grounding.
+
+  datastore and engine are mutually exclusive. See
+  https://cloud.google.com/products/agent-builder
+  """
+
+  datastore: Optional[str]
+  """Optional. Fully-qualified Vertex AI Search data store resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}`"""
+
+  engine: Optional[str]
+  """Optional. Fully-qualified Vertex AI Search engine resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}`"""
+
+
+VertexAISearchOrDict = Union[VertexAISearch, VertexAISearchDict]
+
+
+class VertexRagStoreRagResource(_common.BaseModel):
+  """The definition of the Rag resource."""
+
+  rag_corpus: Optional[str] = Field(
       default=None,
-      description=(
-          'An array instance is valid if its size is less than, or equal to,'
-          ' the value of this keyword.'
-      ),
+      description="""Optional. RagCorpora resource name. Format: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus}`""",
   )
-  enum: Optional[list[Any]] = Field(
+  rag_file_ids: Optional[list[str]] = Field(
       default=None,
-      description=(
-          'Validation succeeds if the instance is equal to one of the elements'
-          ' in this keyword’s array value.'
-      ),
+      description="""Optional. rag_file_id. The files should be in the same rag_corpus set in rag_corpus field.""",
   )
-  properties: Optional[dict[str, 'JSONSchema']] = Field(
+
+
+class VertexRagStoreRagResourceDict(TypedDict, total=False):
+  """The definition of the Rag resource."""
+
+  rag_corpus: Optional[str]
+  """Optional. RagCorpora resource name. Format: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus}`"""
+
+  rag_file_ids: Optional[list[str]]
+  """Optional. rag_file_id. The files should be in the same rag_corpus set in rag_corpus field."""
+
+
+VertexRagStoreRagResourceOrDict = Union[
+    VertexRagStoreRagResource, VertexRagStoreRagResourceDict
+]
+
+
+class RagRetrievalConfigFilter(_common.BaseModel):
+  """Config for filters."""
+
+  metadata_filter: Optional[str] = Field(
+      default=None, description="""Optional. String for metadata filtering."""
+  )
+  vector_distance_threshold: Optional[float] = Field(
       default=None,
-      description=(
-          'Validation succeeds if, for each name that appears in both the'
-          ' instance and as a name within this keyword’s value, the child'
-          ' instance for that name successfully validates against the'
-          ' corresponding schema.'
-      ),
+      description="""Optional. Only returns contexts with vector distance smaller than the threshold.""",
   )
-  required: Optional[list[str]] = Field(
+  vector_similarity_threshold: Optional[float] = Field(
       default=None,
-      description=(
-          'An object instance is valid against this keyword if every item in'
-          ' the array is the name of a property in the instance.'
-      ),
+      description="""Optional. Only returns contexts with vector similarity larger than the threshold.""",
   )
-  min_properties: Optional[int] = Field(
+
+
+class RagRetrievalConfigFilterDict(TypedDict, total=False):
+  """Config for filters."""
+
+  metadata_filter: Optional[str]
+  """Optional. String for metadata filtering."""
+
+  vector_distance_threshold: Optional[float]
+  """Optional. Only returns contexts with vector distance smaller than the threshold."""
+
+  vector_similarity_threshold: Optional[float]
+  """Optional. Only returns contexts with vector similarity larger than the threshold."""
+
+
+RagRetrievalConfigFilterOrDict = Union[
+    RagRetrievalConfigFilter, RagRetrievalConfigFilterDict
+]
+
+
+class RagRetrievalConfigHybridSearch(_common.BaseModel):
+  """Config for Hybrid Search."""
+
+  alpha: Optional[float] = Field(
       default=None,
-      description=(
-          'An object instance is valid if its number of properties is greater'
-          ' than, or equal to, the value of this keyword.'
-      ),
+      description="""Optional. Alpha value controls the weight between dense and sparse vector search results. The range is [0, 1], while 0 means sparse vector search only and 1 means dense vector search only. The default value is 0.5 which balances sparse and dense vector search equally.""",
   )
-  max_properties: Optional[int] = Field(
+
+
+class RagRetrievalConfigHybridSearchDict(TypedDict, total=False):
+  """Config for Hybrid Search."""
+
+  alpha: Optional[float]
+  """Optional. Alpha value controls the weight between dense and sparse vector search results. The range is [0, 1], while 0 means sparse vector search only and 1 means dense vector search only. The default value is 0.5 which balances sparse and dense vector search equally."""
+
+
+RagRetrievalConfigHybridSearchOrDict = Union[
+    RagRetrievalConfigHybridSearch, RagRetrievalConfigHybridSearchDict
+]
+
+
+class RagRetrievalConfigRankingLlmRanker(_common.BaseModel):
+  """Config for LlmRanker."""
+
+  model_name: Optional[str] = Field(
       default=None,
-      description=(
-          'An object instance is valid if its number of properties is less'
-          ' than, or equal to, the value of this keyword.'
-      ),
+      description="""Optional. The model name used for ranking. Format: `gemini-1.5-pro`""",
   )
-  minimum: Optional[float] = Field(
+
+
+class RagRetrievalConfigRankingLlmRankerDict(TypedDict, total=False):
+  """Config for LlmRanker."""
+
+  model_name: Optional[str]
+  """Optional. The model name used for ranking. Format: `gemini-1.5-pro`"""
+
+
+RagRetrievalConfigRankingLlmRankerOrDict = Union[
+    RagRetrievalConfigRankingLlmRanker, RagRetrievalConfigRankingLlmRankerDict
+]
+
+
+class RagRetrievalConfigRankingRankService(_common.BaseModel):
+  """Config for Rank Service."""
+
+  model_name: Optional[str] = Field(
       default=None,
-      description=(
-          'Validation succeeds if the numeric instance is greater than or equal'
-          ' to the given number.'
-      ),
+      description="""Optional. The model name of the rank service. Format: `semantic-ranker-512@latest`""",
   )
-  maximum: Optional[float] = Field(
-      default=None,
-      description=(
-          'Validation succeeds if the numeric instance is less than or equal to'
-          ' the given number.'
-      ),
+
+
+class RagRetrievalConfigRankingRankServiceDict(TypedDict, total=False):
+  """Config for Rank Service."""
+
+  model_name: Optional[str]
+  """Optional. The model name of the rank service. Format: `semantic-ranker-512@latest`"""
+
+
+RagRetrievalConfigRankingRankServiceOrDict = Union[
+    RagRetrievalConfigRankingRankService,
+    RagRetrievalConfigRankingRankServiceDict,
+]
+
+
+class RagRetrievalConfigRanking(_common.BaseModel):
+  """Config for ranking and reranking."""
+
+  llm_ranker: Optional[RagRetrievalConfigRankingLlmRanker] = Field(
+      default=None, description="""Optional. Config for LlmRanker."""
   )
-  min_length: Optional[int] = Field(
-      default=None,
-      description=(
-          'A string instance is valid against this keyword if its length is'
-          ' greater than, or equal to, the value of this keyword.'
-      ),
+  rank_service: Optional[RagRetrievalConfigRankingRankService] = Field(
+      default=None, description="""Optional. Config for Rank Service."""
   )
-  max_length: Optional[int] = Field(
-      default=None,
-      description=(
-          'A string instance is valid against this keyword if its length is'
-          ' less than, or equal to, the value of this keyword.'
-      ),
+
+
+class RagRetrievalConfigRankingDict(TypedDict, total=False):
+  """Config for ranking and reranking."""
+
+  llm_ranker: Optional[RagRetrievalConfigRankingLlmRankerDict]
+  """Optional. Config for LlmRanker."""
+
+  rank_service: Optional[RagRetrievalConfigRankingRankServiceDict]
+  """Optional. Config for Rank Service."""
+
+
+RagRetrievalConfigRankingOrDict = Union[
+    RagRetrievalConfigRanking, RagRetrievalConfigRankingDict
+]
+
+
+class RagRetrievalConfig(_common.BaseModel):
+  """Specifies the context retrieval config."""
+
+  filter: Optional[RagRetrievalConfigFilter] = Field(
+      default=None, description="""Optional. Config for filters."""
   )
-  pattern: Optional[str] = Field(
+  hybrid_search: Optional[RagRetrievalConfigHybridSearch] = Field(
+      default=None, description="""Optional. Config for Hybrid Search."""
+  )
+  ranking: Optional[RagRetrievalConfigRanking] = Field(
       default=None,
-      description=(
-          'A string instance is considered valid if the regular expression'
-          ' matches the instance successfully.'
-      ),
+      description="""Optional. Config for ranking and reranking.""",
   )
-  any_of: Optional[list['JSONSchema']] = Field(
+  top_k: Optional[int] = Field(
       default=None,
-      description=(
-          'An instance validates successfully against this keyword if it'
-          ' validates successfully against at least one schema defined by this'
-          ' keyword’s value.'
-      ),
+      description="""Optional. The number of contexts to retrieve.""",
   )
 
 
-class Schema(_common.BaseModel):
-  """Schema that defines the format of input and output data.
+class RagRetrievalConfigDict(TypedDict, total=False):
+  """Specifies the context retrieval config."""
 
-  Represents a select subset of an OpenAPI 3.0 schema object.
-  """
+  filter: Optional[RagRetrievalConfigFilterDict]
+  """Optional. Config for filters."""
 
-  example: Optional[Any] = Field(
-      default=None,
-      description="""Optional. Example of the object. Will only populated when the object is the root.""",
-  )
-  pattern: Optional[str] = Field(
+  hybrid_search: Optional[RagRetrievalConfigHybridSearchDict]
+  """Optional. Config for Hybrid Search."""
+
+  ranking: Optional[RagRetrievalConfigRankingDict]
+  """Optional. Config for ranking and reranking."""
+
+  top_k: Optional[int]
+  """Optional. The number of contexts to retrieve."""
+
+
+RagRetrievalConfigOrDict = Union[RagRetrievalConfig, RagRetrievalConfigDict]
+
+
+class VertexRagStore(_common.BaseModel):
+  """Retrieve from Vertex RAG Store for grounding."""
+
+  rag_corpora: Optional[list[str]] = Field(
       default=None,
-      description="""Optional. Pattern of the Type.STRING to restrict a string to a regular expression.""",
-  )
-  default: Optional[Any] = Field(
-      default=None, description="""Optional. Default value of the data."""
+      description="""Optional. Deprecated. Please use rag_resources instead.""",
   )
-  max_length: Optional[int] = Field(
+  rag_resources: Optional[list[VertexRagStoreRagResource]] = Field(
       default=None,
-      description="""Optional. Maximum length of the Type.STRING""",
+      description="""Optional. The representation of the rag source. It can be used to specify corpus only or ragfiles. Currently only support one corpus or multiple files from one corpus. In the future we may open up multiple corpora support.""",
   )
-  min_length: Optional[int] = Field(
+  rag_retrieval_config: Optional[RagRetrievalConfig] = Field(
       default=None,
-      description="""Optional. SCHEMA FIELDS FOR TYPE STRING Minimum length of the Type.STRING""",
+      description="""Optional. The retrieval config for the Rag query.""",
   )
-  min_properties: Optional[int] = Field(
+  similarity_top_k: Optional[int] = Field(
       default=None,
-      description="""Optional. Minimum number of the properties for Type.OBJECT.""",
+      description="""Optional. Number of top k results to return from the selected corpora.""",
   )
-  max_properties: Optional[int] = Field(
+  vector_distance_threshold: Optional[float] = Field(
       default=None,
-      description="""Optional. Maximum number of the properties for Type.OBJECT.""",
+      description="""Optional. Only return results with vector distance smaller than the threshold.""",
   )
-  any_of: Optional[list['Schema']] = Field(
+
+
+class VertexRagStoreDict(TypedDict, total=False):
+  """Retrieve from Vertex RAG Store for grounding."""
+
+  rag_corpora: Optional[list[str]]
+  """Optional. Deprecated. Please use rag_resources instead."""
+
+  rag_resources: Optional[list[VertexRagStoreRagResourceDict]]
+  """Optional. The representation of the rag source. It can be used to specify corpus only or ragfiles. Currently only support one corpus or multiple files from one corpus. In the future we may open up multiple corpora support."""
+
+  rag_retrieval_config: Optional[RagRetrievalConfigDict]
+  """Optional. The retrieval config for the Rag query."""
+
+  similarity_top_k: Optional[int]
+  """Optional. Number of top k results to return from the selected corpora."""
+
+  vector_distance_threshold: Optional[float]
+  """Optional. Only return results with vector distance smaller than the threshold."""
+
+
+VertexRagStoreOrDict = Union[VertexRagStore, VertexRagStoreDict]
+
+
+class Retrieval(_common.BaseModel):
+  """Defines a retrieval tool that model can call to access external knowledge."""
+
+  disable_attribution: Optional[bool] = Field(
       default=None,
-      description="""Optional. The value should be validated against any (one or more) of the subschemas in the list.""",
-  )
-  description: Optional[str] = Field(
-      default=None, description="""Optional. The description of the data."""
+      description="""Optional. Deprecated. This option is no longer supported.""",
   )
-  enum: Optional[list[str]] = Field(
+  vertex_ai_search: Optional[VertexAISearch] = Field(
       default=None,
-      description="""Optional. Possible values of the element of primitive type with enum format. Examples: 1. We can define direction as : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]} 2. We can define apartment number as : {type:INTEGER, format:enum, enum:["101", "201", "301"]}""",
+      description="""Set to use data source powered by Vertex AI Search.""",
   )
-  format: Optional[str] = Field(
+  vertex_rag_store: Optional[VertexRagStore] = Field(
       default=None,
-      description="""Optional. The format of the data. Supported formats: for NUMBER type: "float", "double" for INTEGER type: "int32", "int64" for STRING type: "email", "byte", etc""",
+      description="""Set to use data source powered by Vertex RAG store. User data is uploaded via the VertexRagDataService.""",
   )
-  items: Optional['Schema'] = Field(
-      default=None,
+
+
+class RetrievalDict(TypedDict, total=False):
+  """Defines a retrieval tool that model can call to access external knowledge."""
+
+  disable_attribution: Optional[bool]
+  """Optional. Deprecated. This option is no longer supported."""
+
+  vertex_ai_search: Optional[VertexAISearchDict]
+  """Set to use data source powered by Vertex AI Search."""
+
+  vertex_rag_store: Optional[VertexRagStoreDict]
+  """Set to use data source powered by Vertex RAG store. User data is uploaded via the VertexRagDataService."""
+
+
+RetrievalOrDict = Union[Retrieval, RetrievalDict]
+
+
+class ToolCodeExecution(_common.BaseModel):
+  """Tool that executes code generated by the model, and automatically returns the result to the model.
+
+  See also [ExecutableCode]and [CodeExecutionResult] which are input and output
+  to this tool.
+  """
+
+  pass
+
+
+class ToolCodeExecutionDict(TypedDict, total=False):
+  """Tool that executes code generated by the model, and automatically returns the result to the model.
+
+  See also [ExecutableCode]and [CodeExecutionResult] which are input and output
+  to this tool.
+  """
+
+  pass
+
+
+ToolCodeExecutionOrDict = Union[ToolCodeExecution, ToolCodeExecutionDict]
+
+
+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):
+  """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.
+  The difference between this class and the Schema class is that this class is
+  compatible with OpenAPI 3.1 schema objects. And the Schema class is used to
+  make API call to Gemini model.
+  """
+
+  type: Optional[Union[JSONSchemaType, list[JSONSchemaType]]] = Field(
+      default=None,
+      description="""Validation succeeds if the type of the instance matches the type represented by the given type, or matches at least one of the given types.""",
+  )
+  format: Optional[str] = Field(
+      default=None,
+      description='Define semantic information about a string instance.',
+  )
+  title: Optional[str] = Field(
+      default=None,
+      description=(
+          'A preferably short description about the purpose of the instance'
+          ' described by the schema.'
+      ),
+  )
+  description: Optional[str] = Field(
+      default=None,
+      description=(
+          'An explanation about the purpose of the instance described by the'
+          ' schema.'
+      ),
+  )
+  default: Optional[Any] = Field(
+      default=None,
+      description=(
+          'This keyword can be used to supply a default JSON value associated'
+          ' with a particular schema.'
+      ),
+  )
+  items: Optional['JSONSchema'] = Field(
+      default=None,
+      description=(
+          'Validation succeeds if each element of the instance not covered by'
+          ' prefixItems validates against this schema.'
+      ),
+  )
+  min_items: Optional[int] = Field(
+      default=None,
+      description=(
+          'An array instance is valid if its size is greater than, or equal to,'
+          ' the value of this keyword.'
+      ),
+  )
+  max_items: Optional[int] = Field(
+      default=None,
+      description=(
+          'An array instance is valid if its size is less than, or equal to,'
+          ' the value of this keyword.'
+      ),
+  )
+  enum: Optional[list[Any]] = Field(
+      default=None,
+      description=(
+          'Validation succeeds if the instance is equal to one of the elements'
+          ' in this keyword’s array value.'
+      ),
+  )
+  properties: Optional[dict[str, 'JSONSchema']] = Field(
+      default=None,
+      description=(
+          'Validation succeeds if, for each name that appears in both the'
+          ' instance and as a name within this keyword’s value, the child'
+          ' instance for that name successfully validates against the'
+          ' corresponding schema.'
+      ),
+  )
+  required: Optional[list[str]] = Field(
+      default=None,
+      description=(
+          'An object instance is valid against this keyword if every item in'
+          ' the array is the name of a property in the instance.'
+      ),
+  )
+  min_properties: Optional[int] = Field(
+      default=None,
+      description=(
+          'An object instance is valid if its number of properties is greater'
+          ' than, or equal to, the value of this keyword.'
+      ),
+  )
+  max_properties: Optional[int] = Field(
+      default=None,
+      description=(
+          'An object instance is valid if its number of properties is less'
+          ' than, or equal to, the value of this keyword.'
+      ),
+  )
+  minimum: Optional[float] = Field(
+      default=None,
+      description=(
+          'Validation succeeds if the numeric instance is greater than or equal'
+          ' to the given number.'
+      ),
+  )
+  maximum: Optional[float] = Field(
+      default=None,
+      description=(
+          'Validation succeeds if the numeric instance is less than or equal to'
+          ' the given number.'
+      ),
+  )
+  min_length: Optional[int] = Field(
+      default=None,
+      description=(
+          'A string instance is valid against this keyword if its length is'
+          ' greater than, or equal to, the value of this keyword.'
+      ),
+  )
+  max_length: Optional[int] = Field(
+      default=None,
+      description=(
+          'A string instance is valid against this keyword if its length is'
+          ' less than, or equal to, the value of this keyword.'
+      ),
+  )
+  pattern: Optional[str] = Field(
+      default=None,
+      description=(
+          'A string instance is considered valid if the regular expression'
+          ' matches the instance successfully.'
+      ),
+  )
+  any_of: Optional[list['JSONSchema']] = Field(
+      default=None,
+      description=(
+          'An instance validates successfully against this keyword if it'
+          ' validates successfully against at least one schema defined by this'
+          ' keyword’s value.'
+      ),
+  )
+
+
+class Schema(_common.BaseModel):
+  """Schema is used to define the format of input/output data.
+
+  Represents a select subset of an [OpenAPI 3.0 schema
+  object](https://spec.openapis.org/oas/v3.0.3#schema-object). More fields may
+  be added in the future as needed.
+  """
+
+  any_of: Optional[list['Schema']] = Field(
+      default=None,
+      description="""Optional. The value should be validated against any (one or more) of the subschemas in the list.""",
+  )
+  default: Optional[Any] = Field(
+      default=None, description="""Optional. Default value of the data."""
+  )
+  description: Optional[str] = Field(
+      default=None, description="""Optional. The description of the data."""
+  )
+  enum: Optional[list[str]] = Field(
+      default=None,
+      description="""Optional. Possible values of the element of primitive type with enum format. Examples: 1. We can define direction as : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]} 2. We can define apartment number as : {type:INTEGER, format:enum, enum:["101", "201", "301"]}""",
+  )
+  example: Optional[Any] = Field(
+      default=None,
+      description="""Optional. Example of the object. Will only populated when the object is the root.""",
+  )
+  format: Optional[str] = Field(
+      default=None,
+      description="""Optional. The format of the data. Supported formats: for NUMBER type: "float", "double" for INTEGER type: "int32", "int64" for STRING type: "email", "byte", etc""",
+  )
+  items: Optional['Schema'] = Field(
+      default=None,
       description="""Optional. SCHEMA FIELDS FOR TYPE ARRAY Schema of the elements of Type.ARRAY.""",
   )
   max_items: Optional[int] = Field(
       default=None,
       description="""Optional. Maximum number of the elements for Type.ARRAY.""",
   )
+  max_length: Optional[int] = Field(
+      default=None,
+      description="""Optional. Maximum length of the Type.STRING""",
+  )
+  max_properties: Optional[int] = Field(
+      default=None,
+      description="""Optional. Maximum number of the properties for Type.OBJECT.""",
+  )
   maximum: Optional[float] = Field(
       default=None,
       description="""Optional. Maximum value of the Type.INTEGER and Type.NUMBER""",
@@ -1102,6 +1536,14 @@ class Schema(_common.BaseModel):
       default=None,
       description="""Optional. Minimum number of the elements for Type.ARRAY.""",
   )
+  min_length: Optional[int] = Field(
+      default=None,
+      description="""Optional. SCHEMA FIELDS FOR TYPE STRING Minimum length of the Type.STRING""",
+  )
+  min_properties: Optional[int] = Field(
+      default=None,
+      description="""Optional. Minimum number of the properties for Type.OBJECT.""",
+  )
   minimum: Optional[float] = Field(
       default=None,
       description="""Optional. SCHEMA FIELDS FOR TYPE INTEGER and NUMBER Minimum value of the Type.INTEGER and Type.NUMBER""",
@@ -1110,6 +1552,10 @@ class Schema(_common.BaseModel):
       default=None,
       description="""Optional. Indicates if the value may be null.""",
   )
+  pattern: Optional[str] = Field(
+      default=None,
+      description="""Optional. Pattern of the Type.STRING to restrict a string to a regular expression.""",
+  )
   properties: Optional[dict[str, 'Schema']] = Field(
       default=None,
       description="""Optional. SCHEMA FIELDS FOR TYPE OBJECT Properties of Type.OBJECT.""",
@@ -1229,43 +1675,50 @@ class Schema(_common.BaseModel):
     )
     dict_schema_field_names: tuple[str, ...] = ('properties',)  # 'defs' to come
 
-    number_integer_related_field_names: tuple[str, ...] = (
-        'description',
-        'enum',
-        'format',
-        'maximum',
-        'minimum',
-        'title',
-    )
-    string_related_field_names: tuple[str, ...] = (
-        'description',
-        'enum',
-        'format',
-        'max_length',
-        'min_length',
-        'pattern',
-        'title',
-    )
-    object_related_field_names: tuple[str, ...] = (
-        'any_of',
-        'description',
-        'max_properties',
-        'min_properties',
-        'properties',
-        'required',
-        'title',
-    )
-    array_related_field_names: tuple[str, ...] = (
-        'description',
-        'items',
-        'max_items',
-        'min_items',
-        'title',
-    )
-    boolean_related_field_names: tuple[str, ...] = (
-        'description',
-        'title',
+    related_field_names_by_type: dict[str, tuple[str, ...]] = {
+        JSONSchemaType.NUMBER.value: (
+            'description',
+            'enum',
+            'format',
+            'maximum',
+            'minimum',
+            'title',
+        ),
+        JSONSchemaType.STRING.value: (
+            'description',
+            'enum',
+            'format',
+            'max_length',
+            'min_length',
+            'pattern',
+            'title',
+        ),
+        JSONSchemaType.OBJECT.value: (
+            'any_of',
+            'description',
+            'max_properties',
+            'min_properties',
+            'properties',
+            'required',
+            'title',
+        ),
+        JSONSchemaType.ARRAY.value: (
+            'description',
+            'items',
+            'max_items',
+            'min_items',
+            'title',
+        ),
+        JSONSchemaType.BOOLEAN.value: (
+            'description',
+            'title',
+        ),
+    }
+    # Treat `INTEGER` like `NUMBER`.
+    related_field_names_by_type[JSONSchemaType.INTEGER.value] = (
+        related_field_names_by_type[JSONSchemaType.NUMBER.value]
     )
+
     # placeholder for potential gemini api unsupported fields
     gemini_api_unsupported_field_names: tuple[str, ...] = ()
 
@@ -1277,14 +1730,8 @@ class Schema(_common.BaseModel):
       """Returns (non_null_types, nullable)"""
       if json_schema_type is None:
         return [], False
-      if isinstance(json_schema_type, str):
-        if json_schema_type == JSONSchemaType.NULL.value:
-          return [], True
-        return [json_schema_type], False
-      if isinstance(json_schema_type, JSONSchemaType):
-        if json_schema_type == JSONSchemaType.NULL:
-          return [], True
-        return [json_schema_type.value], False
+      if not isinstance(json_schema_type, Sequence):
+        json_schema_type = [json_schema_type]
       non_null_types = []
       nullable = False
       for type_value in json_schema_type:
@@ -1383,37 +1830,11 @@ class Schema(_common.BaseModel):
           schema.nullable = True
         for normalized_type in non_null_types:
           sub_schema_in_any_of = {'type': normalized_type}
-          if normalized_type == JSONSchemaType.BOOLEAN.value:
-            copy_schema_fields(
-                json_schema_dict=json_schema_dict,
-                related_fields_to_copy=boolean_related_field_names,
-                sub_schema_in_any_of=sub_schema_in_any_of,
-            )
-          elif normalized_type in (
-              JSONSchemaType.NUMBER.value,
-              JSONSchemaType.INTEGER.value,
-          ):
+          related_field_names = related_field_names_by_type.get(normalized_type)
+          if related_field_names is not None:
             copy_schema_fields(
                 json_schema_dict=json_schema_dict,
-                related_fields_to_copy=number_integer_related_field_names,
-                sub_schema_in_any_of=sub_schema_in_any_of,
-            )
-          elif normalized_type == JSONSchemaType.STRING.value:
-            copy_schema_fields(
-                json_schema_dict=json_schema_dict,
-                related_fields_to_copy=string_related_field_names,
-                sub_schema_in_any_of=sub_schema_in_any_of,
-            )
-          elif normalized_type == JSONSchemaType.ARRAY.value:
-            copy_schema_fields(
-                json_schema_dict=json_schema_dict,
-                related_fields_to_copy=array_related_field_names,
-                sub_schema_in_any_of=sub_schema_in_any_of,
-            )
-          elif normalized_type == JSONSchemaType.OBJECT.value:
-            copy_schema_fields(
-                json_schema_dict=json_schema_dict,
-                related_fields_to_copy=object_related_field_names,
+                related_fields_to_copy=related_field_names,
                 sub_schema_in_any_of=sub_schema_in_any_of,
             )
           any_of.append(JSONSchema(**sub_schema_in_any_of))
@@ -1473,665 +1894,219 @@ class Schema(_common.BaseModel):
 
 
 class SchemaDict(TypedDict, total=False):
-  """Schema that defines the format of input and output data.
-
-  Represents a select subset of an OpenAPI 3.0 schema object.
-  """
-
-  example: Optional[Any]
-  """Optional. Example of the object. Will only populated when the object is the root."""
-
-  pattern: Optional[str]
-  """Optional. Pattern of the Type.STRING to restrict a string to a regular expression."""
-
-  default: Optional[Any]
-  """Optional. Default value of the data."""
-
-  max_length: Optional[int]
-  """Optional. Maximum length of the Type.STRING"""
-
-  min_length: Optional[int]
-  """Optional. SCHEMA FIELDS FOR TYPE STRING Minimum length of the Type.STRING"""
-
-  min_properties: Optional[int]
-  """Optional. Minimum number of the properties for Type.OBJECT."""
-
-  max_properties: Optional[int]
-  """Optional. Maximum number of the properties for Type.OBJECT."""
-
-  any_of: Optional[list['SchemaDict']]
-  """Optional. The value should be validated against any (one or more) of the subschemas in the list."""
-
-  description: Optional[str]
-  """Optional. The description of the data."""
-
-  enum: Optional[list[str]]
-  """Optional. Possible values of the element of primitive type with enum format. Examples: 1. We can define direction as : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]} 2. We can define apartment number as : {type:INTEGER, format:enum, enum:["101", "201", "301"]}"""
-
-  format: Optional[str]
-  """Optional. The format of the data. Supported formats: for NUMBER type: "float", "double" for INTEGER type: "int32", "int64" for STRING type: "email", "byte", etc"""
-
-  items: Optional['SchemaDict']
-  """Optional. SCHEMA FIELDS FOR TYPE ARRAY Schema of the elements of Type.ARRAY."""
-
-  max_items: Optional[int]
-  """Optional. Maximum number of the elements for Type.ARRAY."""
-
-  maximum: Optional[float]
-  """Optional. Maximum value of the Type.INTEGER and Type.NUMBER"""
-
-  min_items: Optional[int]
-  """Optional. Minimum number of the elements for Type.ARRAY."""
-
-  minimum: Optional[float]
-  """Optional. SCHEMA FIELDS FOR TYPE INTEGER and NUMBER Minimum value of the Type.INTEGER and Type.NUMBER"""
-
-  nullable: Optional[bool]
-  """Optional. Indicates if the value may be null."""
-
-  properties: Optional[dict[str, 'SchemaDict']]
-  """Optional. SCHEMA FIELDS FOR TYPE OBJECT Properties of Type.OBJECT."""
-
-  property_ordering: Optional[list[str]]
-  """Optional. The order of the properties. Not a standard field in open api spec. Only used to support the order of the properties."""
-
-  required: Optional[list[str]]
-  """Optional. Required properties of Type.OBJECT."""
-
-  title: Optional[str]
-  """Optional. The title of the Schema."""
-
-  type: Optional[Type]
-  """Optional. The type of the data."""
-
-
-SchemaOrDict = Union[Schema, SchemaDict]
-
-
-class ModelSelectionConfig(_common.BaseModel):
-  """Config for model selection."""
-
-  feature_selection_preference: Optional[FeatureSelectionPreference] = Field(
-      default=None, description="""Options for feature selection preference."""
-  )
-
-
-class ModelSelectionConfigDict(TypedDict, total=False):
-  """Config for model selection."""
-
-  feature_selection_preference: Optional[FeatureSelectionPreference]
-  """Options for feature selection preference."""
-
-
-ModelSelectionConfigOrDict = Union[
-    ModelSelectionConfig, ModelSelectionConfigDict
-]
-
-
-class SafetySetting(_common.BaseModel):
-  """Safety settings."""
-
-  method: Optional[HarmBlockMethod] = Field(
-      default=None,
-      description="""Determines if the harm block method uses probability or probability
-      and severity scores.""",
-  )
-  category: Optional[HarmCategory] = Field(
-      default=None, description="""Required. Harm category."""
-  )
-  threshold: Optional[HarmBlockThreshold] = Field(
-      default=None, description="""Required. The harm block threshold."""
-  )
-
-
-class SafetySettingDict(TypedDict, total=False):
-  """Safety settings."""
-
-  method: Optional[HarmBlockMethod]
-  """Determines if the harm block method uses probability or probability
-      and severity scores."""
-
-  category: Optional[HarmCategory]
-  """Required. Harm category."""
-
-  threshold: Optional[HarmBlockThreshold]
-  """Required. The harm block threshold."""
-
-
-SafetySettingOrDict = Union[SafetySetting, SafetySettingDict]
-
-
-class FunctionDeclaration(_common.BaseModel):
-  """Defines a function that the model can generate JSON inputs for.
-
-  The inputs are based on `OpenAPI 3.0 specifications
-  <https://spec.openapis.org/oas/v3.0.3>`_.
-  """
-
-  response: Optional[Schema] = Field(
-      default=None,
-      description="""Describes the output from the function in the OpenAPI JSON Schema
-      Object format.""",
-  )
-  description: Optional[str] = Field(
-      default=None,
-      description="""Optional. Description and purpose of the function. Model uses it to decide how and whether to call the function.""",
-  )
-  name: Optional[str] = Field(
-      default=None,
-      description="""Required. The name of the function to call. Must start with a letter or an underscore. Must be a-z, A-Z, 0-9, or contain underscores, dots and dashes, with a maximum length of 64.""",
-  )
-  parameters: Optional[Schema] = Field(
-      default=None,
-      description="""Optional. Describes the parameters to this function in JSON Schema Object format. Reflects the Open API 3.03 Parameter Object. string Key: the name of the parameter. Parameter names are case sensitive. Schema Value: the Schema defining the type used for the parameter. For function with no parameters, this can be left unset. Parameter names must start with a letter or an underscore and must only contain chars a-z, A-Z, 0-9, or underscores with a maximum length of 64. Example with 1 required and 1 optional parameter: type: OBJECT properties: param1: type: STRING param2: type: INTEGER required: - param1""",
-  )
-
-  @classmethod
-  def from_callable_with_api_option(
-      cls,
-      *,
-      callable: Callable[..., Any],
-      api_option: Literal['VERTEX_AI', 'GEMINI_API'] = 'GEMINI_API',
-  ) -> 'FunctionDeclaration':
-    """Converts a Callable to a FunctionDeclaration based on the API option.
-
-    Supported API option is 'VERTEX_AI' or 'GEMINI_API'. If api_option is unset,
-    it will default to 'GEMINI_API'. If unsupported api_option is provided, it
-    will raise ValueError.
-    """
-    supported_api_options = ['VERTEX_AI', 'GEMINI_API']
-    if api_option not in supported_api_options:
-      raise ValueError(
-          f'Unsupported api_option value: {api_option}. Supported api_option'
-          f' value is one of: {supported_api_options}.'
-      )
-    from . import _automatic_function_calling_util
-
-    parameters_properties = {}
-    for name, param in inspect.signature(callable).parameters.items():
-      if param.kind in (
-          inspect.Parameter.POSITIONAL_OR_KEYWORD,
-          inspect.Parameter.KEYWORD_ONLY,
-          inspect.Parameter.POSITIONAL_ONLY,
-      ):
-        schema = _automatic_function_calling_util._parse_schema_from_parameter(
-            api_option, param, callable.__name__
-        )
-        parameters_properties[name] = schema
-    declaration = FunctionDeclaration(
-        name=callable.__name__,
-        description=callable.__doc__,
-    )
-    if parameters_properties:
-      declaration.parameters = Schema(
-          type='OBJECT',
-          properties=parameters_properties,
-      )
-      declaration.parameters.required = (
-          _automatic_function_calling_util._get_required_fields(
-              declaration.parameters
-          )
-      )
-    if api_option == 'GEMINI_API':
-      return declaration
-
-    return_annotation = inspect.signature(callable).return_annotation
-    if return_annotation is inspect._empty:
-      return declaration
+  """Schema is used to define the format of input/output data.
 
-    declaration.response = (
-        _automatic_function_calling_util._parse_schema_from_parameter(
-            api_option,
-            inspect.Parameter(
-                'return_value',
-                inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                annotation=return_annotation,
-            ),
-            callable.__name__,
-        )
-    )
-    return declaration
-
-  @classmethod
-  def from_callable(
-      cls,
-      *,
-      client: 'BaseApiClient',
-      callable: Callable[..., Any],
-  ) -> 'FunctionDeclaration':
-    """Converts a Callable to a FunctionDeclaration based on the client."""
-    if client.vertexai:
-      return cls.from_callable_with_api_option(
-          callable=callable, api_option='VERTEX_AI'
-      )
-    else:
-      return cls.from_callable_with_api_option(
-          callable=callable, api_option='GEMINI_API'
-      )
-
-
-class FunctionDeclarationDict(TypedDict, total=False):
-  """Defines a function that the model can generate JSON inputs for.
-
-  The inputs are based on `OpenAPI 3.0 specifications
-  <https://spec.openapis.org/oas/v3.0.3>`_.
-  """
-
-  response: Optional[SchemaDict]
-  """Describes the output from the function in the OpenAPI JSON Schema
-      Object format."""
-
-  description: Optional[str]
-  """Optional. Description and purpose of the function. Model uses it to decide how and whether to call the function."""
-
-  name: Optional[str]
-  """Required. The name of the function to call. Must start with a letter or an underscore. Must be a-z, A-Z, 0-9, or contain underscores, dots and dashes, with a maximum length of 64."""
-
-  parameters: Optional[SchemaDict]
-  """Optional. Describes the parameters to this function in JSON Schema Object format. Reflects the Open API 3.03 Parameter Object. string Key: the name of the parameter. Parameter names are case sensitive. Schema Value: the Schema defining the type used for the parameter. For function with no parameters, this can be left unset. Parameter names must start with a letter or an underscore and must only contain chars a-z, A-Z, 0-9, or underscores with a maximum length of 64. Example with 1 required and 1 optional parameter: type: OBJECT properties: param1: type: STRING param2: type: INTEGER required: - param1"""
-
-
-FunctionDeclarationOrDict = Union[FunctionDeclaration, FunctionDeclarationDict]
-
-
-class GoogleSearch(_common.BaseModel):
-  """Tool to support Google Search in Model. Powered by Google."""
-
-  pass
-
-
-class GoogleSearchDict(TypedDict, total=False):
-  """Tool to support Google Search in Model. Powered by Google."""
-
-  pass
-
-
-GoogleSearchOrDict = Union[GoogleSearch, GoogleSearchDict]
-
-
-class DynamicRetrievalConfig(_common.BaseModel):
-  """Describes the options to customize dynamic retrieval."""
-
-  mode: Optional[DynamicRetrievalConfigMode] = Field(
-      default=None,
-      description="""The mode of the predictor to be used in dynamic retrieval.""",
-  )
-  dynamic_threshold: Optional[float] = Field(
-      default=None,
-      description="""Optional. The threshold to be used in dynamic retrieval. If not set, a system default value is used.""",
-  )
-
-
-class DynamicRetrievalConfigDict(TypedDict, total=False):
-  """Describes the options to customize dynamic retrieval."""
-
-  mode: Optional[DynamicRetrievalConfigMode]
-  """The mode of the predictor to be used in dynamic retrieval."""
-
-  dynamic_threshold: Optional[float]
-  """Optional. The threshold to be used in dynamic retrieval. If not set, a system default value is used."""
-
-
-DynamicRetrievalConfigOrDict = Union[
-    DynamicRetrievalConfig, DynamicRetrievalConfigDict
-]
-
-
-class GoogleSearchRetrieval(_common.BaseModel):
-  """Tool to retrieve public web data for grounding, powered by Google."""
-
-  dynamic_retrieval_config: Optional[DynamicRetrievalConfig] = Field(
-      default=None,
-      description="""Specifies the dynamic retrieval configuration for the given source.""",
-  )
-
-
-class GoogleSearchRetrievalDict(TypedDict, total=False):
-  """Tool to retrieve public web data for grounding, powered by Google."""
-
-  dynamic_retrieval_config: Optional[DynamicRetrievalConfigDict]
-  """Specifies the dynamic retrieval configuration for the given source."""
-
-
-GoogleSearchRetrievalOrDict = Union[
-    GoogleSearchRetrieval, GoogleSearchRetrievalDict
-]
-
-
-class VertexAISearch(_common.BaseModel):
-  """Retrieve from Vertex AI Search datastore or engine for grounding.
-
-  datastore and engine are mutually exclusive. See
-  https://cloud.google.com/products/agent-builder
-  """
-
-  datastore: Optional[str] = Field(
-      default=None,
-      description="""Optional. Fully-qualified Vertex AI Search data store resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}`""",
-  )
-  engine: Optional[str] = Field(
-      default=None,
-      description="""Optional. Fully-qualified Vertex AI Search engine resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}`""",
-  )
-
-
-class VertexAISearchDict(TypedDict, total=False):
-  """Retrieve from Vertex AI Search datastore or engine for grounding.
-
-  datastore and engine are mutually exclusive. See
-  https://cloud.google.com/products/agent-builder
-  """
-
-  datastore: Optional[str]
-  """Optional. Fully-qualified Vertex AI Search data store resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/dataStores/{dataStore}`"""
-
-  engine: Optional[str]
-  """Optional. Fully-qualified Vertex AI Search engine resource ID. Format: `projects/{project}/locations/{location}/collections/{collection}/engines/{engine}`"""
-
-
-VertexAISearchOrDict = Union[VertexAISearch, VertexAISearchDict]
-
-
-class VertexRagStoreRagResource(_common.BaseModel):
-  """The definition of the Rag resource."""
-
-  rag_corpus: Optional[str] = Field(
-      default=None,
-      description="""Optional. RagCorpora resource name. Format: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus}`""",
-  )
-  rag_file_ids: Optional[list[str]] = Field(
-      default=None,
-      description="""Optional. rag_file_id. The files should be in the same rag_corpus set in rag_corpus field.""",
-  )
-
-
-class VertexRagStoreRagResourceDict(TypedDict, total=False):
-  """The definition of the Rag resource."""
-
-  rag_corpus: Optional[str]
-  """Optional. RagCorpora resource name. Format: `projects/{project}/locations/{location}/ragCorpora/{rag_corpus}`"""
-
-  rag_file_ids: Optional[list[str]]
-  """Optional. rag_file_id. The files should be in the same rag_corpus set in rag_corpus field."""
-
-
-VertexRagStoreRagResourceOrDict = Union[
-    VertexRagStoreRagResource, VertexRagStoreRagResourceDict
-]
-
-
-class RagRetrievalConfigFilter(_common.BaseModel):
-  """Config for filters."""
-
-  metadata_filter: Optional[str] = Field(
-      default=None, description="""Optional. String for metadata filtering."""
-  )
-  vector_distance_threshold: Optional[float] = Field(
-      default=None,
-      description="""Optional. Only returns contexts with vector distance smaller than the threshold.""",
-  )
-  vector_similarity_threshold: Optional[float] = Field(
-      default=None,
-      description="""Optional. Only returns contexts with vector similarity larger than the threshold.""",
-  )
-
-
-class RagRetrievalConfigFilterDict(TypedDict, total=False):
-  """Config for filters."""
-
-  metadata_filter: Optional[str]
-  """Optional. String for metadata filtering."""
-
-  vector_distance_threshold: Optional[float]
-  """Optional. Only returns contexts with vector distance smaller than the threshold."""
-
-  vector_similarity_threshold: Optional[float]
-  """Optional. Only returns contexts with vector similarity larger than the threshold."""
-
-
-RagRetrievalConfigFilterOrDict = Union[
-    RagRetrievalConfigFilter, RagRetrievalConfigFilterDict
-]
-
-
-class RagRetrievalConfigHybridSearch(_common.BaseModel):
-  """Config for Hybrid Search."""
-
-  alpha: Optional[float] = Field(
-      default=None,
-      description="""Optional. Alpha value controls the weight between dense and sparse vector search results. The range is [0, 1], while 0 means sparse vector search only and 1 means dense vector search only. The default value is 0.5 which balances sparse and dense vector search equally.""",
-  )
-
-
-class RagRetrievalConfigHybridSearchDict(TypedDict, total=False):
-  """Config for Hybrid Search."""
-
-  alpha: Optional[float]
-  """Optional. Alpha value controls the weight between dense and sparse vector search results. The range is [0, 1], while 0 means sparse vector search only and 1 means dense vector search only. The default value is 0.5 which balances sparse and dense vector search equally."""
-
-
-RagRetrievalConfigHybridSearchOrDict = Union[
-    RagRetrievalConfigHybridSearch, RagRetrievalConfigHybridSearchDict
-]
-
-
-class RagRetrievalConfigRankingLlmRanker(_common.BaseModel):
-  """Config for LlmRanker."""
-
-  model_name: Optional[str] = Field(
-      default=None,
-      description="""Optional. The model name used for ranking. Format: `gemini-1.5-pro`""",
-  )
-
-
-class RagRetrievalConfigRankingLlmRankerDict(TypedDict, total=False):
-  """Config for LlmRanker."""
-
-  model_name: Optional[str]
-  """Optional. The model name used for ranking. Format: `gemini-1.5-pro`"""
-
-
-RagRetrievalConfigRankingLlmRankerOrDict = Union[
-    RagRetrievalConfigRankingLlmRanker, RagRetrievalConfigRankingLlmRankerDict
-]
-
-
-class RagRetrievalConfigRankingRankService(_common.BaseModel):
-  """Config for Rank Service."""
-
-  model_name: Optional[str] = Field(
-      default=None,
-      description="""Optional. The model name of the rank service. Format: `semantic-ranker-512@latest`""",
-  )
-
-
-class RagRetrievalConfigRankingRankServiceDict(TypedDict, total=False):
-  """Config for Rank Service."""
-
-  model_name: Optional[str]
-  """Optional. The model name of the rank service. Format: `semantic-ranker-512@latest`"""
-
-
-RagRetrievalConfigRankingRankServiceOrDict = Union[
-    RagRetrievalConfigRankingRankService,
-    RagRetrievalConfigRankingRankServiceDict,
-]
-
-
-class RagRetrievalConfigRanking(_common.BaseModel):
-  """Config for ranking and reranking."""
-
-  llm_ranker: Optional[RagRetrievalConfigRankingLlmRanker] = Field(
-      default=None, description="""Optional. Config for LlmRanker."""
-  )
-  rank_service: Optional[RagRetrievalConfigRankingRankService] = Field(
-      default=None, description="""Optional. Config for Rank Service."""
-  )
-
-
-class RagRetrievalConfigRankingDict(TypedDict, total=False):
-  """Config for ranking and reranking."""
-
-  llm_ranker: Optional[RagRetrievalConfigRankingLlmRankerDict]
-  """Optional. Config for LlmRanker."""
-
-  rank_service: Optional[RagRetrievalConfigRankingRankServiceDict]
-  """Optional. Config for Rank Service."""
+  Represents a select subset of an [OpenAPI 3.0 schema
+  object](https://spec.openapis.org/oas/v3.0.3#schema-object). More fields may
+  be added in the future as needed.
+  """
 
+  any_of: Optional[list['SchemaDict']]
+  """Optional. The value should be validated against any (one or more) of the subschemas in the list."""
 
-RagRetrievalConfigRankingOrDict = Union[
-    RagRetrievalConfigRanking, RagRetrievalConfigRankingDict
-]
+  default: Optional[Any]
+  """Optional. Default value of the data."""
 
+  description: Optional[str]
+  """Optional. The description of the data."""
 
-class RagRetrievalConfig(_common.BaseModel):
-  """Specifies the context retrieval config."""
+  enum: Optional[list[str]]
+  """Optional. Possible values of the element of primitive type with enum format. Examples: 1. We can define direction as : {type:STRING, format:enum, enum:["EAST", NORTH", "SOUTH", "WEST"]} 2. We can define apartment number as : {type:INTEGER, format:enum, enum:["101", "201", "301"]}"""
 
-  filter: Optional[RagRetrievalConfigFilter] = Field(
-      default=None, description="""Optional. Config for filters."""
-  )
-  hybrid_search: Optional[RagRetrievalConfigHybridSearch] = Field(
-      default=None, description="""Optional. Config for Hybrid Search."""
-  )
-  ranking: Optional[RagRetrievalConfigRanking] = Field(
-      default=None,
-      description="""Optional. Config for ranking and reranking.""",
-  )
-  top_k: Optional[int] = Field(
-      default=None,
-      description="""Optional. The number of contexts to retrieve.""",
-  )
+  example: Optional[Any]
+  """Optional. Example of the object. Will only populated when the object is the root."""
 
+  format: Optional[str]
+  """Optional. The format of the data. Supported formats: for NUMBER type: "float", "double" for INTEGER type: "int32", "int64" for STRING type: "email", "byte", etc"""
 
-class RagRetrievalConfigDict(TypedDict, total=False):
-  """Specifies the context retrieval config."""
+  items: Optional['SchemaDict']
+  """Optional. SCHEMA FIELDS FOR TYPE ARRAY Schema of the elements of Type.ARRAY."""
 
-  filter: Optional[RagRetrievalConfigFilterDict]
-  """Optional. Config for filters."""
+  max_items: Optional[int]
+  """Optional. Maximum number of the elements for Type.ARRAY."""
 
-  hybrid_search: Optional[RagRetrievalConfigHybridSearchDict]
-  """Optional. Config for Hybrid Search."""
+  max_length: Optional[int]
+  """Optional. Maximum length of the Type.STRING"""
 
-  ranking: Optional[RagRetrievalConfigRankingDict]
-  """Optional. Config for ranking and reranking."""
+  max_properties: Optional[int]
+  """Optional. Maximum number of the properties for Type.OBJECT."""
 
-  top_k: Optional[int]
-  """Optional. The number of contexts to retrieve."""
+  maximum: Optional[float]
+  """Optional. Maximum value of the Type.INTEGER and Type.NUMBER"""
 
+  min_items: Optional[int]
+  """Optional. Minimum number of the elements for Type.ARRAY."""
 
-RagRetrievalConfigOrDict = Union[RagRetrievalConfig, RagRetrievalConfigDict]
+  min_length: Optional[int]
+  """Optional. SCHEMA FIELDS FOR TYPE STRING Minimum length of the Type.STRING"""
 
+  min_properties: Optional[int]
+  """Optional. Minimum number of the properties for Type.OBJECT."""
 
-class VertexRagStore(_common.BaseModel):
-  """Retrieve from Vertex RAG Store for grounding."""
+  minimum: Optional[float]
+  """Optional. SCHEMA FIELDS FOR TYPE INTEGER and NUMBER Minimum value of the Type.INTEGER and Type.NUMBER"""
 
-  rag_corpora: Optional[list[str]] = Field(
-      default=None,
-      description="""Optional. Deprecated. Please use rag_resources instead.""",
-  )
-  rag_resources: Optional[list[VertexRagStoreRagResource]] = Field(
-      default=None,
-      description="""Optional. The representation of the rag source. It can be used to specify corpus only or ragfiles. Currently only support one corpus or multiple files from one corpus. In the future we may open up multiple corpora support.""",
-  )
-  rag_retrieval_config: Optional[RagRetrievalConfig] = Field(
-      default=None,
-      description="""Optional. The retrieval config for the Rag query.""",
-  )
-  similarity_top_k: Optional[int] = Field(
-      default=None,
-      description="""Optional. Number of top k results to return from the selected corpora.""",
-  )
-  vector_distance_threshold: Optional[float] = Field(
-      default=None,
-      description="""Optional. Only return results with vector distance smaller than the threshold.""",
-  )
+  nullable: Optional[bool]
+  """Optional. Indicates if the value may be null."""
 
+  pattern: Optional[str]
+  """Optional. Pattern of the Type.STRING to restrict a string to a regular expression."""
 
-class VertexRagStoreDict(TypedDict, total=False):
-  """Retrieve from Vertex RAG Store for grounding."""
+  properties: Optional[dict[str, 'SchemaDict']]
+  """Optional. SCHEMA FIELDS FOR TYPE OBJECT Properties of Type.OBJECT."""
 
-  rag_corpora: Optional[list[str]]
-  """Optional. Deprecated. Please use rag_resources instead."""
+  property_ordering: Optional[list[str]]
+  """Optional. The order of the properties. Not a standard field in open api spec. Only used to support the order of the properties."""
 
-  rag_resources: Optional[list[VertexRagStoreRagResourceDict]]
-  """Optional. The representation of the rag source. It can be used to specify corpus only or ragfiles. Currently only support one corpus or multiple files from one corpus. In the future we may open up multiple corpora support."""
+  required: Optional[list[str]]
+  """Optional. Required properties of Type.OBJECT."""
 
-  rag_retrieval_config: Optional[RagRetrievalConfigDict]
-  """Optional. The retrieval config for the Rag query."""
+  title: Optional[str]
+  """Optional. The title of the Schema."""
 
-  similarity_top_k: Optional[int]
-  """Optional. Number of top k results to return from the selected corpora."""
+  type: Optional[Type]
+  """Optional. The type of the data."""
 
-  vector_distance_threshold: Optional[float]
-  """Optional. Only return results with vector distance smaller than the threshold."""
 
+SchemaOrDict = Union[Schema, SchemaDict]
 
-VertexRagStoreOrDict = Union[VertexRagStore, VertexRagStoreDict]
 
+class FunctionDeclaration(_common.BaseModel):
+  """Structured representation of a function declaration as defined by the [OpenAPI 3.0 specification](https://spec.openapis.org/oas/v3.0.3).
 
-class Retrieval(_common.BaseModel):
-  """Defines a retrieval tool that model can call to access external knowledge."""
+  Included in this declaration are the function name, description, parameters
+  and response type. This FunctionDeclaration is a representation of a block of
+  code that can be used as a `Tool` by the model and executed by the client.
+  """
 
-  disable_attribution: Optional[bool] = Field(
+  description: Optional[str] = Field(
       default=None,
-      description="""Optional. Deprecated. This option is no longer supported.""",
+      description="""Optional. Description and purpose of the function. Model uses it to decide how and whether to call the function.""",
   )
-  vertex_ai_search: Optional[VertexAISearch] = Field(
+  name: Optional[str] = Field(
       default=None,
-      description="""Set to use data source powered by Vertex AI Search.""",
+      description="""Required. The name of the function to call. Must start with a letter or an underscore. Must be a-z, A-Z, 0-9, or contain underscores, dots and dashes, with a maximum length of 64.""",
   )
-  vertex_rag_store: Optional[VertexRagStore] = Field(
+  parameters: Optional[Schema] = Field(
       default=None,
-      description="""Set to use data source powered by Vertex RAG store. User data is uploaded via the VertexRagDataService.""",
+      description="""Optional. Describes the parameters to this function in JSON Schema Object format. Reflects the Open API 3.03 Parameter Object. string Key: the name of the parameter. Parameter names are case sensitive. Schema Value: the Schema defining the type used for the parameter. For function with no parameters, this can be left unset. Parameter names must start with a letter or an underscore and must only contain chars a-z, A-Z, 0-9, or underscores with a maximum length of 64. Example with 1 required and 1 optional parameter: type: OBJECT properties: param1: type: STRING param2: type: INTEGER required: - param1""",
+  )
+  response: Optional[Schema] = Field(
+      default=None,
+      description="""Optional. Describes the output from this function in JSON Schema format. Reflects the Open API 3.03 Response Object. The Schema defines the type used for the response value of the function.""",
   )
 
+  @classmethod
+  def from_callable_with_api_option(
+      cls,
+      *,
+      callable: Callable[..., Any],
+      api_option: Literal['VERTEX_AI', 'GEMINI_API'] = 'GEMINI_API',
+  ) -> 'FunctionDeclaration':
+    """Converts a Callable to a FunctionDeclaration based on the API option.
 
-class RetrievalDict(TypedDict, total=False):
-  """Defines a retrieval tool that model can call to access external knowledge."""
-
-  disable_attribution: Optional[bool]
-  """Optional. Deprecated. This option is no longer supported."""
+    Supported API option is 'VERTEX_AI' or 'GEMINI_API'. If api_option is unset,
+    it will default to 'GEMINI_API'. If unsupported api_option is provided, it
+    will raise ValueError.
+    """
+    supported_api_options = ['VERTEX_AI', 'GEMINI_API']
+    if api_option not in supported_api_options:
+      raise ValueError(
+          f'Unsupported api_option value: {api_option}. Supported api_option'
+          f' value is one of: {supported_api_options}.'
+      )
+    from . import _automatic_function_calling_util
 
-  vertex_ai_search: Optional[VertexAISearchDict]
-  """Set to use data source powered by Vertex AI Search."""
+    parameters_properties = {}
+    for name, param in inspect.signature(callable).parameters.items():
+      if param.kind in (
+          inspect.Parameter.POSITIONAL_OR_KEYWORD,
+          inspect.Parameter.KEYWORD_ONLY,
+          inspect.Parameter.POSITIONAL_ONLY,
+      ):
+        schema = _automatic_function_calling_util._parse_schema_from_parameter(
+            api_option, param, callable.__name__
+        )
+        parameters_properties[name] = schema
+    declaration = FunctionDeclaration(
+        name=callable.__name__,
+        description=callable.__doc__,
+    )
+    if parameters_properties:
+      declaration.parameters = Schema(
+          type='OBJECT',
+          properties=parameters_properties,
+      )
+      declaration.parameters.required = (
+          _automatic_function_calling_util._get_required_fields(
+              declaration.parameters
+          )
+      )
+    if api_option == 'GEMINI_API':
+      return declaration
 
-  vertex_rag_store: Optional[VertexRagStoreDict]
-  """Set to use data source powered by Vertex RAG store. User data is uploaded via the VertexRagDataService."""
+    return_annotation = inspect.signature(callable).return_annotation
+    if return_annotation is inspect._empty:
+      return declaration
 
+    declaration.response = (
+        _automatic_function_calling_util._parse_schema_from_parameter(
+            api_option,
+            inspect.Parameter(
+                'return_value',
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=return_annotation,
+            ),
+            callable.__name__,
+        )
+    )
+    return declaration
 
-RetrievalOrDict = Union[Retrieval, RetrievalDict]
+  @classmethod
+  def from_callable(
+      cls,
+      *,
+      client: 'BaseApiClient',
+      callable: Callable[..., Any],
+  ) -> 'FunctionDeclaration':
+    """Converts a Callable to a FunctionDeclaration based on the client."""
+    if client.vertexai:
+      return cls.from_callable_with_api_option(
+          callable=callable, api_option='VERTEX_AI'
+      )
+    else:
+      return cls.from_callable_with_api_option(
+          callable=callable, api_option='GEMINI_API'
+      )
 
 
-class ToolCodeExecution(_common.BaseModel):
-  """Tool that executes code generated by the model, and automatically returns the result to the model.
+class FunctionDeclarationDict(TypedDict, total=False):
+  """Structured representation of a function declaration as defined by the [OpenAPI 3.0 specification](https://spec.openapis.org/oas/v3.0.3).
 
-  See also [ExecutableCode]and [CodeExecutionResult] which are input and output
-  to this tool.
+  Included in this declaration are the function name, description, parameters
+  and response type. This FunctionDeclaration is a representation of a block of
+  code that can be used as a `Tool` by the model and executed by the client.
   """
 
-  pass
-
+  description: Optional[str]
+  """Optional. Description and purpose of the function. Model uses it to decide how and whether to call the function."""
 
-class ToolCodeExecutionDict(TypedDict, total=False):
-  """Tool that executes code generated by the model, and automatically returns the result to the model.
+  name: Optional[str]
+  """Required. The name of the function to call. Must start with a letter or an underscore. Must be a-z, A-Z, 0-9, or contain underscores, dots and dashes, with a maximum length of 64."""
 
-  See also [ExecutableCode]and [CodeExecutionResult] which are input and output
-  to this tool.
-  """
+  parameters: Optional[SchemaDict]
+  """Optional. Describes the parameters to this function in JSON Schema Object format. Reflects the Open API 3.03 Parameter Object. string Key: the name of the parameter. Parameter names are case sensitive. Schema Value: the Schema defining the type used for the parameter. For function with no parameters, this can be left unset. Parameter names must start with a letter or an underscore and must only contain chars a-z, A-Z, 0-9, or underscores with a maximum length of 64. Example with 1 required and 1 optional parameter: type: OBJECT properties: param1: type: STRING param2: type: INTEGER required: - param1"""
 
-  pass
+  response: Optional[SchemaDict]
+  """Optional. Describes the output from this function in JSON Schema format. Reflects the Open API 3.03 Response Object. The Schema defines the type used for the response value of the function."""
 
 
-ToolCodeExecutionOrDict = Union[ToolCodeExecution, ToolCodeExecutionDict]
+FunctionDeclarationOrDict = Union[FunctionDeclaration, FunctionDeclarationDict]
 
 
 class Tool(_common.BaseModel):
   """Tool details of a tool that the model may use to generate a response."""
 
-  function_declarations: Optional[list[FunctionDeclaration]] = Field(
-      default=None,
-      description="""List of function declarations that the tool supports.""",
-  )
   retrieval: Optional[Retrieval] = Field(
       default=None,
       description="""Optional. Retrieval tool type. System will always execute the provided retrieval tool(s) to get external knowledge to answer the prompt. Retrieval results are presented to the model for generation.""",
@@ -2149,14 +2124,15 @@ class Tool(_common.BaseModel):
       default=None,
       description="""Optional. CodeExecution tool type. Enables the model to execute code as part of generation. This field is only used by the Gemini Developer API services.""",
   )
+  function_declarations: Optional[list[FunctionDeclaration]] = Field(
+      default=None,
+      description="""Optional. Function tool type. One or more function declarations to be passed to the model along with the current user query. Model may decide to call a subset of these functions by populating FunctionCall in the response. User should provide a FunctionResponse for each function call in the next turn. Based on the function responses, Model will generate the final response back to the user. Maximum 128 function declarations can be provided.""",
+  )
 
 
 class ToolDict(TypedDict, total=False):
   """Tool details of a tool that the model may use to generate a response."""
 
-  function_declarations: Optional[list[FunctionDeclarationDict]]
-  """List of function declarations that the tool supports."""
-
   retrieval: Optional[RetrievalDict]
   """Optional. Retrieval tool type. System will always execute the provided retrieval tool(s) to get external knowledge to answer the prompt. Retrieval results are presented to the model for generation."""
 
@@ -2170,6 +2146,9 @@ class ToolDict(TypedDict, total=False):
   code_execution: Optional[ToolCodeExecutionDict]
   """Optional. CodeExecution tool type. Enables the model to execute code as part of generation. This field is only used by the Gemini Developer API services."""
 
+  function_declarations: Optional[list[FunctionDeclarationDict]]
+  """Optional. Function tool type. One or more function declarations to be passed to the model along with the current user query. Model may decide to call a subset of these functions by populating FunctionCall in the response. User should provide a FunctionResponse for each function call in the next turn. Based on the function responses, Model will generate the final response back to the user. Maximum 128 function declarations can be provided."""
+
 
 ToolOrDict = Union[Tool, ToolDict]
 ToolListUnion = list[Union[Tool, Callable[..., Any]]]
@@ -5544,6 +5523,7 @@ ListModelsResponseOrDict = Union[ListModelsResponse, ListModelsResponseDict]
 
 
 class UpdateModelConfig(_common.BaseModel):
+  """Configuration for updating a tuned model."""
 
   http_options: Optional[HttpOptions] = Field(
       default=None, description="""Used to override HTTP request options."""
@@ -5553,6 +5533,7 @@ class UpdateModelConfig(_common.BaseModel):
 
 
 class UpdateModelConfigDict(TypedDict, total=False):
+  """Configuration for updating a tuned model."""
 
   http_options: Optional[HttpOptionsDict]
   """Used to override HTTP request options."""
@@ -5568,12 +5549,14 @@ UpdateModelConfigOrDict = Union[UpdateModelConfig, UpdateModelConfigDict]
 
 
 class _UpdateModelParameters(_common.BaseModel):
+  """Configuration for updating a tuned model."""
 
   model: Optional[str] = Field(default=None, description="""""")
   config: Optional[UpdateModelConfig] = Field(default=None, description="""""")
 
 
 class _UpdateModelParametersDict(TypedDict, total=False):
+  """Configuration for updating a tuned model."""
 
   model: Optional[str]
   """"""
@@ -5588,6 +5571,7 @@ _UpdateModelParametersOrDict = Union[
 
 
 class DeleteModelConfig(_common.BaseModel):
+  """Configuration for deleting a tuned model."""
 
   http_options: Optional[HttpOptions] = Field(
       default=None, description="""Used to override HTTP request options."""
@@ -5595,6 +5579,7 @@ class DeleteModelConfig(_common.BaseModel):
 
 
 class DeleteModelConfigDict(TypedDict, total=False):
+  """Configuration for deleting a tuned model."""
 
   http_options: Optional[HttpOptionsDict]
   """Used to override HTTP request options."""
@@ -5604,6 +5589,7 @@ DeleteModelConfigOrDict = Union[DeleteModelConfig, DeleteModelConfigDict]
 
 
 class _DeleteModelParameters(_common.BaseModel):
+  """Parameters for deleting a tuned model."""
 
   model: Optional[str] = Field(default=None, description="""""")
   config: Optional[DeleteModelConfig] = Field(
@@ -5612,6 +5598,7 @@ class _DeleteModelParameters(_common.BaseModel):
 
 
 class _DeleteModelParametersDict(TypedDict, total=False):
+  """Parameters for deleting a tuned model."""
 
   model: Optional[str]
   """"""
@@ -7585,7 +7572,7 @@ class _CreateCachedContentParameters(_common.BaseModel):
 
   model: Optional[str] = Field(
       default=None,
-      description="""ID of the model to use. Example: gemini-1.5-flash""",
+      description="""ID of the model to use. Example: gemini-2.0-flash""",
   )
   config: Optional[CreateCachedContentConfig] = Field(
       default=None,
@@ -7598,7 +7585,7 @@ class _CreateCachedContentParametersDict(TypedDict, total=False):
   """Parameters for caches.create method."""
 
   model: Optional[str]
-  """ID of the model to use. Example: gemini-1.5-flash"""
+  """ID of the model to use. Example: gemini-2.0-flash"""
 
   config: Optional[CreateCachedContentConfigDict]
   """Configuration that contains optional parameters.
@@ -9603,6 +9590,10 @@ class LiveServerContent(_common.BaseModel):
       default=None,
       description="""If true, indicates that a client message has interrupted current model generation. If the client is playing out the content in realtime, this is a good signal to stop and empty the current queue.""",
   )
+  grounding_metadata: Optional[GroundingMetadata] = Field(
+      default=None,
+      description="""Metadata returned to client when grounding is enabled.""",
+  )
   generation_complete: Optional[bool] = Field(
       default=None,
       description="""If true, indicates that the model is done generating. When model is
@@ -9645,6 +9636,9 @@ class LiveServerContentDict(TypedDict, total=False):
   interrupted: Optional[bool]
   """If true, indicates that a client message has interrupted current model generation. If the client is playing out the content in realtime, this is a good signal to stop and empty the current queue."""
 
+  grounding_metadata: Optional[GroundingMetadataDict]
+  """Metadata returned to client when grounding is enabled."""
+
   generation_complete: Optional[bool]
   """If true, indicates that the model is done generating. When model is
       interrupted while generating there will be no generation_complete message
@@ -10762,6 +10756,7 @@ if _is_pillow_image_imported:
 else:
   BlobImageUnion = Blob  # type: ignore[misc]
 
+
 BlobImageUnionDict = Union[BlobImageUnion, BlobDict]