feat: add support for Python 3.14.

PiperOrigin-RevId: 819940464

Author: speedstorm1

.github/workflows/import.yml

@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
 
     steps:
       - name: Checkout repository

.github/workflows/mypy.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.14']
 
     steps:
       - name: Checkout code
@@ -29,6 +29,7 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install mypy
+          sudo apt-get update && sudo apt-get install -y libjpeg-dev zlib1g-dev
           pip install -r requirements.txt
 
       - name: Run mypy  ${{ matrix.python-version }}

google/genai/_replay_api_client.py

@@ -56,8 +56,13 @@ def _normalize_json_case(obj: Any) -> Any:
     return [_normalize_json_case(item) for item in obj]
   elif isinstance(obj, enum.Enum):
     return obj.value
-  else:
-    return obj
+  elif isinstance(obj, str):
+    # Python >= 3.14 has a new division by zero error message.
+    if 'division by zero' in obj:
+      return obj.replace(
+          'division by zero', 'integer division or modulo by zero'
+      )
+  return obj
 
 
 def _equals_ignore_key_case(obj1: Any, obj2: Any) -> bool:
@@ -88,7 +93,7 @@ def _equals_ignore_key_case(obj1: Any, obj2: Any) -> bool:
 
 def _redact_version_numbers(version_string: str) -> str:
   """Redacts version numbers in the form x.y.z from a string."""
-  return re.sub(r'\d+\.\d+\.\d+', '{VERSION_NUMBER}', version_string)
+  return re.sub(r'\d+\.\d+\.\d+[a-zA-Z0-9]*', '{VERSION_NUMBER}', version_string)
 
 
 def _redact_language_label(language_label: str) -> str:

google/genai/mypy.ini

@@ -1,7 +1,7 @@
 [mypy]
 exclude = (tests/|_test_api_client\.py)
 plugins = pydantic.mypy
-; we are ignoring 'unused-ignore' because we run mypy on Python 3.9 - 3.13 and
+; we are ignoring 'unused-ignore' because we run mypy on Python 3.9 - 3.14 and
 ; some errors in _automatic_function_calling_util.py only apply in 3.10+
 ; 'import-not-found' and 'import-untyped' are environment specific
 disable_error_code = import-not-found, import-untyped, unused-ignore

google/genai/types.py

@@ -1696,6 +1696,10 @@ class JSONSchema(_common.BaseModel):
           ' matches the instance successfully.'
       ),
   )
+  additional_properties: Optional[Any] = Field(
+      default=None,
+      description="""Can either be a boolean or an object; controls the presence of additional properties.""",
+  )
   any_of: Optional[list['JSONSchema']] = Field(
       default=None,
       description=(
@@ -1704,6 +1708,20 @@ class JSONSchema(_common.BaseModel):
           ' keyword’s value.'
       ),
   )
+  unique_items: Optional[bool] = Field(
+      default=None,
+      description="""Boolean value that indicates whether the items in an array are unique.""",
+  )
+  ref: Optional[str] = Field(
+      default=None,
+      alias='$ref',
+      description="""Allows indirect references between schema nodes.""",
+  )
+  defs: Optional[dict[str, 'JSONSchema']] = Field(
+      default=None,
+      alias='$defs',
+      description="""Schema definitions to be used with $ref.""",
+  )
 
 
 class Schema(_common.BaseModel):
@@ -1915,7 +1933,7 @@ def from_json_schema(
     list_schema_field_names: tuple[str, ...] = (
         'any_of',  # 'one_of', 'all_of', 'not' to come
     )
-    dict_schema_field_names: tuple[str, ...] = ('properties',)  # 'defs' to come
+    dict_schema_field_names: tuple[str, ...] = ('properties',)
 
     related_field_names_by_type: dict[str, tuple[str, ...]] = {
         JSONSchemaType.NUMBER.value: (
@@ -1964,6 +1982,23 @@ def from_json_schema(
     # placeholder for potential gemini api unsupported fields
     gemini_api_unsupported_field_names: tuple[str, ...] = ()
 
+    def _resolve_ref(
+        ref_path: str, root_schema_dict: dict[str, Any]
+    ) -> dict[str, Any]:
+      """Helper to resolve a $ref path."""
+      current = root_schema_dict
+      for part in ref_path.lstrip('#/').split('/'):
+        if part == '$defs':
+          part = 'defs'
+        current = current[part]
+      current.pop('title', None)
+      if 'properties' in current and current['properties'] is not None:
+        for prop_schema in current['properties'].values():
+          if isinstance(prop_schema, dict):
+            prop_schema.pop('title', None)
+
+      return current
+
     def normalize_json_schema_type(
         json_schema_type: Optional[
             Union[JSONSchemaType, Sequence[JSONSchemaType], str, Sequence[str]]
@@ -1972,11 +2007,16 @@ def normalize_json_schema_type(
       """Returns (non_null_types, nullable)"""
       if json_schema_type is None:
         return [], False
-      if not isinstance(json_schema_type, Sequence):
-        json_schema_type = [json_schema_type]
+      type_sequence: Sequence[Union[JSONSchemaType, str]]
+      if isinstance(json_schema_type, str) or not isinstance(
+          json_schema_type, Sequence
+      ):
+        type_sequence = [json_schema_type]
+      else:
+        type_sequence = json_schema_type
       non_null_types = []
       nullable = False
-      for type_value in json_schema_type:
+      for type_value in type_sequence:
         if isinstance(type_value, JSONSchemaType):
           type_value = type_value.value
         if type_value == JSONSchemaType.NULL.value:
@@ -1996,7 +2036,10 @@ def raise_error_if_cannot_convert(
       for field_name, field_value in json_schema_dict.items():
         if field_value is None:
           continue
-        if field_name not in google_schema_field_names:
+        if field_name not in google_schema_field_names and field_name not in [
+            'ref',
+            'defs',
+        ]:
           raise ValueError(
               f'JSONSchema field "{field_name}" is not supported by the '
               'Schema object. And the "raise_error_on_unsupported_field" '
@@ -2026,12 +2069,19 @@ def copy_schema_fields(
         )
 
     def convert_json_schema(
-        json_schema: JSONSchema,
+        current_json_schema: JSONSchema,
+        root_json_schema_dict: dict[str, Any],
         api_option: Literal['VERTEX_AI', 'GEMINI_API'],
         raise_error_on_unsupported_field: bool,
     ) -> 'Schema':
       schema = Schema()
-      json_schema_dict = json_schema.model_dump()
+      json_schema_dict = current_json_schema.model_dump()
+
+      if json_schema_dict.get('ref'):
+        json_schema_dict = _resolve_ref(
+            json_schema_dict['ref'], root_json_schema_dict
+        )
+
       raise_error_if_cannot_convert(
           json_schema_dict=json_schema_dict,
           api_option=api_option,
@@ -2057,6 +2107,7 @@ def convert_json_schema(
       non_null_types, nullable = normalize_json_schema_type(
           json_schema_dict.get('type', None)
       )
+      is_union_like_type = len(non_null_types) > 1
       if len(non_null_types) > 1:
         logger.warning(
             'JSONSchema type is union-like, e.g. ["null", "string", "array"]. '
@@ -2086,50 +2137,89 @@ def convert_json_schema(
       # Pass 2: the JSONSchema.type is not union-like,
       # e.g. 'string', ['string'], ['null', 'string'].
       for field_name, field_value in json_schema_dict.items():
-        if field_value is None:
+        if field_value is None or field_name == 'defs':
           continue
         if field_name in schema_field_names:
+          if field_name == 'items' and not field_value:
+            continue
           schema_field_value: 'Schema' = convert_json_schema(
-              json_schema=JSONSchema(**field_value),
+              current_json_schema=JSONSchema(**field_value),
+              root_json_schema_dict=root_json_schema_dict,
               api_option=api_option,
               raise_error_on_unsupported_field=raise_error_on_unsupported_field,
           )
           setattr(schema, field_name, schema_field_value)
         elif field_name in list_schema_field_names:
           list_schema_field_value: list['Schema'] = [
               convert_json_schema(
-                  json_schema=JSONSchema(**this_field_value),
+                  current_json_schema=JSONSchema(**this_field_value),
+                  root_json_schema_dict=root_json_schema_dict,
                   api_option=api_option,
                   raise_error_on_unsupported_field=raise_error_on_unsupported_field,
               )
               for this_field_value in field_value
           ]
           setattr(schema, field_name, list_schema_field_value)
+          if not schema.type and not is_union_like_type:
+            schema.type = Type('OBJECT')
         elif field_name in dict_schema_field_names:
           dict_schema_field_value: dict[str, 'Schema'] = {
               key: convert_json_schema(
-                  json_schema=JSONSchema(**value),
+                  current_json_schema=JSONSchema(**value),
+                  root_json_schema_dict=root_json_schema_dict,
                   api_option=api_option,
                   raise_error_on_unsupported_field=raise_error_on_unsupported_field,
               )
               for key, value in field_value.items()
           }
           setattr(schema, field_name, dict_schema_field_value)
         elif field_name == 'type':
-          # non_null_types can only be empty or have one element.
-          # because already handled union-like case above.
           non_null_types, nullable = normalize_json_schema_type(field_value)
           if nullable:
             schema.nullable = True
           if non_null_types:
             schema.type = Type(non_null_types[0])
         else:
-          setattr(schema, field_name, field_value)
+          if (
+              hasattr(schema, field_name)
+              and field_name != 'additional_properties'
+          ):
+            setattr(schema, field_name, field_value)
+
+      if (
+          schema.type == 'ARRAY'
+          and schema.items
+          and not schema.items.model_dump(exclude_unset=True)
+      ):
+        schema.items = None
+
+      if schema.any_of and len(schema.any_of) == 2:
+        nullable_part = None
+        type_part = None
+        for part in schema.any_of:
+          # A schema representing `None` will either be of type NULL or just be nullable.
+          part_dict = part.model_dump(exclude_unset=True)
+          if part_dict == {'nullable': True} or part_dict == {'type': 'NULL'}:
+            nullable_part = part
+          else:
+            type_part = part
+
+        # If we found both parts, unwrap them into a single schema.
+        if nullable_part and type_part:
+          default_value = schema.default
+          schema = type_part
+          schema.nullable = True
+          # Carry the default value over to the unwrapped schema
+          if default_value is not None:
+            schema.default = default_value
 
       return schema
 
+    # This is the initial call to the recursive function.
+    root_schema_dict = json_schema.model_dump()
     return convert_json_schema(
-        json_schema=json_schema,
+        current_json_schema=json_schema,
+        root_json_schema_dict=root_schema_dict,
         api_option=api_option,
         raise_error_on_unsupported_field=raise_error_on_unsupported_field,
     )
@@ -2371,7 +2461,32 @@ def from_callable_with_api_option(
             json_schema_dict = _automatic_function_calling_util._add_unevaluated_items_to_fixed_len_tuple_schema(
                 json_schema_dict
             )
-            parameters_json_schema[name] = json_schema_dict
+            if 'prefixItems' in json_schema_dict:
+              parameters_json_schema[name] = json_schema_dict
+              continue
+
+            union_args = typing.get_args(param.annotation)
+            has_primitive = any(
+                _automatic_function_calling_util._is_builtin_primitive_or_compound(
+                    arg
+                )
+                for arg in union_args
+            )
+            if (
+                '$ref' in json_schema_dict or '$defs' in json_schema_dict
+            ) and has_primitive:
+              # This is a complex schema with a primitive (e.g., str | MyModel)
+              # that is better represented by raw JSON schema.
+              parameters_json_schema[name] = json_schema_dict
+              continue
+
+            schema = Schema.from_json_schema(
+                json_schema=JSONSchema(**json_schema_dict),
+                api_option=api_option,
+            )
+            if param.default is not inspect.Parameter.empty:
+              schema.default = param.default
+            parameters_properties[name] = schema
           except Exception as e:
             _automatic_function_calling_util._raise_for_unsupported_param(
                 param, callable.__name__, e

pyproject.toml

@@ -22,6 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Internet",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
@@ -51,4 +52,4 @@ packages = [
 include-package-data = true
 
 [tools.setuptools.package_data]
-"google.genai" = ["py.typed"]
+"google.genai" = ["py.typed"]

requirements.txt

@@ -15,18 +15,18 @@ pluggy==1.5.0
 py==1.11.0
 pyasn1==0.6.1
 pyasn1_modules==0.4.1
-pydantic==2.11.0
-pydantic_core==2.33.0
+pydantic==2.12.0
+pydantic_core==2.41.1
 pytest==8.3.4
 pytest-asyncio==0.25.0
 pytest-cov==6.0.0
 pytest-parallel==0.1.1
 requests==2.32.4
 rsa==4.9
 tenacity==8.2.3
-typing_extensions==4.12.2
+typing_extensions>=4.14.1
 urllib3==2.5.0
 websockets==15.0.0
-mcp==1.14.0; python_version > '3.9'
-sentencepiece >= 0.2.0
+mcp>=1.14.0; python_version > '3.9'
+sentencepiece>=0.2.0
 protobuf