google-genai 1.43.0__tar.gz → 1.45.0__tar.gz

{google_genai-1.43.0/google_genai.egg-info → google_genai-1.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.43.0
+Version: 1.45.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
@@ -279,6 +280,25 @@ http_options = types.HttpOptions(
 client=Client(..., http_options=http_options)
 ```
 
+### Custom base url
+
+In some cases you might need a custom base url (for example, API gateway proxy
+ server) and bypass some authentication checks for project, location, or API key.
+You may pass the custom base url like this:
+
+```python
+
+base_url = 'https://test-api-gateway-proxy.com'
+client = Client(
+  vertexai=True,
+  http_options={
+      'base_url': base_url,
+      'headers': {'Authorization': 'Bearer test_token'},
+  },
+)
+
+```
+
 ## Types
 
 Parameter types can be specified as either dictionaries(`TypedDict`) or

{google_genai-1.43.0 → google_genai-1.45.0}/README.md

@@ -242,6 +242,25 @@ http_options = types.HttpOptions(
 client=Client(..., http_options=http_options)
 ```
 
+### Custom base url
+
+In some cases you might need a custom base url (for example, API gateway proxy
+ server) and bypass some authentication checks for project, location, or API key.
+You may pass the custom base url like this:
+
+```python
+
+base_url = 'https://test-api-gateway-proxy.com'
+client = Client(
+  vertexai=True,
+  http_options={
+      'base_url': base_url,
+      'headers': {'Authorization': 'Bearer test_token'},
+  },
+)
+
+```
+
 ## Types
 
 Parameter types can be specified as either dictionaries(`TypedDict`) or

{google_genai-1.43.0 → google_genai-1.45.0}/google/genai/_api_client.py

@@ -547,6 +547,7 @@ class BaseApiClient:
       http_options: Optional[HttpOptionsOrDict] = None,
   ):
     self.vertexai = vertexai
+    self.custom_base_url = None
     if self.vertexai is None:
       if os.environ.get('GOOGLE_GENAI_USE_VERTEXAI', '0').lower() in [
           'true',
@@ -628,11 +629,17 @@ class BaseApiClient:
         )
         self.api_key = None
 
+      self.custom_base_url = (
+          validated_http_options.base_url
+          if validated_http_options.base_url
+          else None
+      )
+
       # Skip fetching project from ADC if base url is provided in http options.
       if (
           not self.project
           and not self.api_key
-          and not validated_http_options.base_url
+          and not self.custom_base_url
       ):
         credentials, self.project = load_auth(project=None)
         if not self._credentials:
@@ -640,7 +647,7 @@ class BaseApiClient:
 
       has_sufficient_auth = (self.project and self.location) or self.api_key
 
-      if not has_sufficient_auth and not validated_http_options.base_url:
+      if not has_sufficient_auth and not self.custom_base_url:
         # Skip sufficient auth check if base url is provided in http options.
         raise ValueError(
             'Project and location or API key must be set when using the Vertex '
@@ -648,9 +655,11 @@ class BaseApiClient:
         )
       if self.api_key or self.location == 'global':
         self._http_options.base_url = f'https://aiplatform.googleapis.com/'
-      elif validated_http_options.base_url and not has_sufficient_auth:
+      elif self.custom_base_url and not has_sufficient_auth:
         # Avoid setting default base url and api version if base_url provided.
-        self._http_options.base_url = validated_http_options.base_url
+        # API gateway proxy can use the auth in custom headers, not url.
+        # Enable custom url if auth is not sufficient.
+        self._http_options.base_url = self.custom_base_url
       else:
         self._http_options.base_url = (
             f'https://{self.location}-aiplatform.googleapis.com/'
@@ -683,6 +692,7 @@ class BaseApiClient:
     client_args, async_client_args = self._ensure_httpx_ssl_ctx(
         self._http_options
     )
+    self._async_httpx_client_args = async_client_args
     self._httpx_client = SyncHttpxClient(**client_args)
     self._async_httpx_client = AsyncHttpxClient(**async_client_args)
     if self._use_aiohttp():
@@ -897,6 +907,11 @@ class BaseApiClient:
     )
 
   def _websocket_base_url(self) -> str:
+    has_sufficient_auth = (self.project and self.location) or self.api_key
+    if self.custom_base_url and not has_sufficient_auth:
+      # API gateway proxy can use the auth in custom headers, not url.
+      # Enable custom url if auth is not sufficient.
+      return self.custom_base_url
     url_parts = urlparse(self._http_options.base_url)
     return url_parts._replace(scheme='wss').geturl()  # type: ignore[arg-type, return-value]
 

{google_genai-1.43.0 → google_genai-1.45.0}/google/genai/_common.py

@@ -272,9 +272,7 @@ def convert_to_dict(obj: object, convert_keys: bool = False) -> Any:
     return convert_to_dict(obj.model_dump(exclude_none=True), convert_keys)
   elif isinstance(obj, dict):
     return {
-        maybe_snake_to_camel(key, convert_keys): convert_to_dict(
-            value, convert_keys
-        )
+        maybe_snake_to_camel(key, convert_keys): convert_to_dict(value)
         for key, value in obj.items()
     }
   elif isinstance(obj, list):

{google_genai-1.43.0 → google_genai-1.45.0}/google/genai/_operations_converters.py

@@ -201,11 +201,11 @@ def _GeneratedVideo_from_mldev(
     parent_object: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
-  if getv(from_object, ['_self']) is not None:
+  if getv(from_object, ['video']) is not None:
     setv(
         to_object,
         ['video'],
-        _Video_from_mldev(getv(from_object, ['_self']), to_object),
+        _Video_from_mldev(getv(from_object, ['video']), to_object),
     )
 
   return to_object
@@ -261,14 +261,14 @@ def _Video_from_mldev(
     parent_object: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
-  if getv(from_object, ['video', 'uri']) is not None:
-    setv(to_object, ['uri'], getv(from_object, ['video', 'uri']))
+  if getv(from_object, ['uri']) is not None:
+    setv(to_object, ['uri'], getv(from_object, ['uri']))
 
-  if getv(from_object, ['video', 'encodedVideo']) is not None:
+  if getv(from_object, ['encodedVideo']) is not None:
     setv(
         to_object,
         ['video_bytes'],
-        base_t.t_bytes(getv(from_object, ['video', 'encodedVideo'])),
+        base_t.t_bytes(getv(from_object, ['encodedVideo'])),
     )
 
   if getv(from_object, ['encoding']) is not None:

{google_genai-1.43.0 → google_genai-1.45.0}/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-1.43.0 → google_genai-1.45.0}/google/genai/_transformers.py

@@ -41,28 +41,6 @@ from . import types
 
 logger = logging.getLogger('google_genai._transformers')
 
-
-def _is_duck_type_of(obj: Any, cls: type[pydantic.BaseModel]) -> bool:
-  """Checks if an object has all of the fields of a Pydantic model.
-
-  This is a duck-typing alternative to `isinstance` to solve dual-import
-  problems. It returns False for dictionaries, which should be handled by
-  `isinstance(obj, dict)`.
-
-  Args:
-    obj: The object to check.
-    cls: The Pydantic model class to duck-type against.
-
-  Returns:
-    True if the object has all the fields defined in the Pydantic model, False
-    otherwise.
-  """
-  if isinstance(obj, dict) or not hasattr(cls, 'model_fields'):
-    return False
-
-  # Check if the object has all of the Pydantic model's defined fields.
-  return all(hasattr(obj, field) for field in cls.model_fields)
-
 if sys.version_info >= (3, 10):
   VersionedUnionType = builtin_types.UnionType
   _UNION_TYPES = (typing.Union, builtin_types.UnionType)
@@ -94,6 +72,28 @@ metric_name_sdk_api_map = {
 metric_name_api_sdk_map = {v: k for k, v in metric_name_sdk_api_map.items()}
 
 
+def _is_duck_type_of(obj: Any, cls: type[pydantic.BaseModel]) -> bool:
+  """Checks if an object has all of the fields of a Pydantic model.
+
+  This is a duck-typing alternative to `isinstance` to solve dual-import
+  problems. It returns False for dictionaries, which should be handled by
+  `isinstance(obj, dict)`.
+
+  Args:
+    obj: The object to check.
+    cls: The Pydantic model class to duck-type against.
+
+  Returns:
+    True if the object has all the fields defined in the Pydantic model, False
+    otherwise.
+  """
+  if isinstance(obj, dict) or not hasattr(cls, 'model_fields'):
+    return False
+
+  # Check if the object has all of the Pydantic model's defined fields.
+  return all(hasattr(obj, field) for field in cls.model_fields)
+
+
 def _resource_name(
     client: _api_client.BaseApiClient,
     resource_name: str,
@@ -306,7 +306,7 @@ def t_function_response(
     raise ValueError('function_response is required.')
   if isinstance(function_response, dict):
     return types.FunctionResponse.model_validate(function_response)
-  elif isinstance(function_response, types.FunctionResponse):
+  elif _is_duck_type_of(function_response, types.FunctionResponse):
     return function_response
   else:
     raise TypeError(
@@ -342,8 +342,8 @@ def t_blob(blob: types.BlobImageUnionDict) -> types.Blob:
   if not blob:
     raise ValueError('blob is required.')
 
-  if isinstance(blob, types.Blob):
-    return blob
+  if _is_duck_type_of(blob, types.Blob):
+    return blob  # type: ignore[return-value]
 
   if isinstance(blob, dict):
     return types.Blob.model_validate(blob)
@@ -383,10 +383,10 @@ def t_part(part: Optional[types.PartUnionDict]) -> types.Part:
     raise ValueError('content part is required.')
   if isinstance(part, str):
     return types.Part(text=part)
-  if isinstance(part, types.File):
-    if not part.uri or not part.mime_type:
+  if _is_duck_type_of(part, types.File):
+    if not part.uri or not part.mime_type:  # type: ignore[union-attr]
       raise ValueError('file uri and mime_type are required.')
-    return types.Part.from_uri(file_uri=part.uri, mime_type=part.mime_type)
+    return types.Part.from_uri(file_uri=part.uri, mime_type=part.mime_type)  # type: ignore[union-attr]
   if isinstance(part, dict):
     try:
       return types.Part.model_validate(part)
@@ -449,8 +449,8 @@ def t_content(
 ) -> types.Content:
   if content is None:
     raise ValueError('content is required.')
-  if isinstance(content, types.Content):
-    return content
+  if _is_duck_type_of(content, types.Content):
+    return content  # type: ignore[return-value]
   if isinstance(content, dict):
     try:
       return types.Content.model_validate(content)
@@ -461,15 +461,15 @@ def t_content(
           if possible_part.function_call
           else types.UserContent(parts=[possible_part])
       )
-  if isinstance(content, types.File):
-    return types.UserContent(parts=[t_part(content)])
-  if isinstance(content, types.Part):
+  if _is_duck_type_of(content, types.File):
+    return types.UserContent(parts=[t_part(content)])  # type: ignore[arg-type]
+  if _is_duck_type_of(content, types.Part):
     return (
-        types.ModelContent(parts=[content])
-        if content.function_call
-        else types.UserContent(parts=[content])
+        types.ModelContent(parts=[content])  # type: ignore[arg-type]
+        if content.function_call  # type: ignore[union-attr]
+        else types.UserContent(parts=[content])  # type: ignore[arg-type]
     )
-  return types.UserContent(parts=content)
+  return types.UserContent(parts=content)  # type: ignore[arg-type]
 
 
 def t_contents_for_embed(
@@ -516,8 +516,8 @@ def t_contents(
   ) -> TypeGuard[types.PartUnionDict]:
     if (
         isinstance(part, str)
-        or isinstance(part, types.File)
-        or isinstance(part, types.Part)
+        or _is_duck_type_of(part, types.File)
+        or _is_duck_type_of(part, types.Part)
     ):
       return True
 
@@ -884,12 +884,12 @@ def t_schema(
     return types.Schema.model_validate(origin)
   if isinstance(origin, EnumMeta):
     return _process_enum(origin, client)
-  if isinstance(origin, types.Schema):
-    if dict(origin) == dict(types.Schema()):
+  if _is_duck_type_of(origin, types.Schema):
+    if dict(origin) == dict(types.Schema()):  # type: ignore [arg-type]
       # response_schema value was coerced to an empty Schema instance because
       # it did not adhere to the Schema field annotation
       _raise_for_unsupported_schema_type(origin)
-    schema = origin.model_dump(exclude_unset=True)
+    schema = origin.model_dump(exclude_unset=True)  # type: ignore[union-attr]
     process_schema(schema, client)
     return types.Schema.model_validate(schema)
 
@@ -926,8 +926,8 @@ def t_speech_config(
 ) -> Optional[types.SpeechConfig]:
   if not origin:
     return None
-  if isinstance(origin, types.SpeechConfig):
-    return origin
+  if _is_duck_type_of(origin, types.SpeechConfig):
+    return origin  # type: ignore[return-value]
   if isinstance(origin, str):
     return types.SpeechConfig(
         voice_config=types.VoiceConfig(
@@ -943,17 +943,17 @@ def t_speech_config(
 def t_live_speech_config(
     origin: types.SpeechConfigOrDict,
 ) -> Optional[types.SpeechConfig]:
-  if isinstance(origin, types.SpeechConfig):
+  if _is_duck_type_of(origin, types.SpeechConfig):
     speech_config = origin
   if isinstance(origin, dict):
     speech_config = types.SpeechConfig.model_validate(origin)
 
-  if speech_config.multi_speaker_voice_config is not None:
+  if speech_config.multi_speaker_voice_config is not None:  # type: ignore[union-attr]
     raise ValueError(
         'multi_speaker_voice_config is not supported in the live API.'
     )
 
-  return speech_config
+  return speech_config  # type: ignore[return-value]
 
 
 def t_tool(
@@ -969,7 +969,7 @@ def t_tool(
             )
         ]
     )
-  elif McpTool is not None and isinstance(origin, McpTool):
+  elif McpTool is not None and _is_duck_type_of(origin, McpTool):
     return mcp_to_gemini_tool(origin)
   elif isinstance(origin, dict):
     return types.Tool.model_validate(origin)
@@ -1012,13 +1012,13 @@ def t_batch_job_source(
 ) -> types.BatchJobSource:
   if isinstance(src, dict):
     src = types.BatchJobSource(**src)
-  if isinstance(src, types.BatchJobSource):
+  if _is_duck_type_of(src, types.BatchJobSource):
     vertex_sources = sum(
-        [src.gcs_uri is not None, src.bigquery_uri is not None]
+        [src.gcs_uri is not None, src.bigquery_uri is not None]  # type: ignore[union-attr]
     )
     mldev_sources = sum([
-        src.inlined_requests is not None,
-        src.file_name is not None,
+        src.inlined_requests is not None,  # type: ignore[union-attr]
+        src.file_name is not None,  # type: ignore[union-attr]
     ])
     if client.vertexai:
       if mldev_sources or vertex_sources != 1:
@@ -1033,7 +1033,7 @@ def t_batch_job_source(
             '`inlined_embed_content_requests`, or `embed_content_file_name` '
             'must be set, other sources are not supported in Gemini API.'
         )
-    return src
+    return src  # type: ignore[return-value]
 
   elif isinstance(src, list):
     return types.BatchJobSource(inlined_requests=src)
@@ -1063,7 +1063,7 @@ def t_embedding_batch_job_source(
   if isinstance(src, dict):
     src = types.EmbeddingsBatchJobSource(**src)
 
-  if isinstance(src, types.EmbeddingsBatchJobSource):
+  if _is_duck_type_of(src, types.EmbeddingsBatchJobSource):
     mldev_sources = sum([
         src.inlined_requests is not None,
         src.file_name is not None,
@@ -1098,7 +1098,7 @@ def t_batch_job_destination(
       )
     else:
       raise ValueError(f'Unsupported destination: {dest}')
-  elif isinstance(dest, types.BatchJobDestination):
+  elif _is_duck_type_of(dest, types.BatchJobDestination):
     return dest
   else:
     raise ValueError(f'Unsupported destination: {dest}')
@@ -1198,13 +1198,13 @@ def t_file_name(
     name: Optional[Union[str, types.File, types.Video, types.GeneratedVideo]],
 ) -> str:
   # Remove the files/ prefix since it's added to the url path.
-  if isinstance(name, types.File):
-    name = name.name
-  elif isinstance(name, types.Video):
-    name = name.uri
-  elif isinstance(name, types.GeneratedVideo):
-    if name.video is not None:
-      name = name.video.uri
+  if _is_duck_type_of(name, types.File):
+    name = name.name  # type: ignore[union-attr]
+  elif _is_duck_type_of(name, types.Video):
+    name = name.uri  # type: ignore[union-attr]
+  elif _is_duck_type_of(name, types.GeneratedVideo):
+    if name.video is not None:  # type: ignore[union-attr]
+      name = name.video.uri  # type: ignore[union-attr]
     else:
       name = None
 
@@ -1247,7 +1247,7 @@ def t_tuning_job_status(status: str) -> Union[types.JobState, str]:
 def t_content_strict(content: types.ContentOrDict) -> types.Content:
   if isinstance(content, dict):
     return types.Content.model_validate(content)
-  elif isinstance(content, types.Content):
+  elif _is_duck_type_of(content, types.Content):
     return content
   else:
     raise ValueError(

{google_genai-1.43.0 → google_genai-1.45.0}/google/genai/live.py

@@ -980,7 +980,8 @@ class AsyncLive(_api_module.BaseModule):
       api_key = self._api_client.api_key
       version = self._api_client._http_options.api_version
       uri = f'{base_url}/ws/google.cloud.aiplatform.{version}.LlmBidiService/BidiGenerateContent'
-      headers = self._api_client._http_options.headers or {}
+      original_headers = self._api_client._http_options.headers
+      headers = original_headers.copy() if original_headers is not None else {}
 
       request_dict = _common.convert_to_dict(
           live_converters._LiveConnectParameters_to_vertex(
@@ -1012,12 +1013,24 @@ class AsyncLive(_api_module.BaseModule):
       bearer_token = creds.token
       original_headers = self._api_client._http_options.headers
       headers = original_headers.copy() if original_headers is not None else {}
-      headers['Authorization'] = f'Bearer {bearer_token}'
+      if not headers.get('Authorization'):
+        headers['Authorization'] = f'Bearer {bearer_token}'
       version = self._api_client._http_options.api_version
-      uri = f'{base_url}/ws/google.cloud.aiplatform.{version}.LlmBidiService/BidiGenerateContent'
+
+      has_sufficient_auth = (
+          self._api_client.project and self._api_client.location
+      )
+      if self._api_client.custom_base_url and not has_sufficient_auth:
+        # API gateway proxy can use the auth in custom headers, not url.
+        # Enable custom url if auth is not sufficient.
+        uri = self._api_client.custom_base_url
+        # Keep the model as is.
+        transformed_model = model
+      else:
+        uri = f'{base_url}/ws/google.cloud.aiplatform.{version}.LlmBidiService/BidiGenerateContent'
       location = self._api_client.location
       project = self._api_client.project
-      if transformed_model.startswith('publishers/'):
+      if transformed_model.startswith('publishers/') and project and location:
         transformed_model = (
             f'projects/{project}/locations/{location}/' + transformed_model
         )

{google_genai-1.43.0 → google_genai-1.45.0}/google/genai/models.py

@@ -2262,11 +2262,11 @@ def _GeneratedVideo_from_mldev(
     parent_object: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
-  if getv(from_object, ['_self']) is not None:
+  if getv(from_object, ['video']) is not None:
     setv(
         to_object,
         ['video'],
-        _Video_from_mldev(getv(from_object, ['_self']), to_object),
+        _Video_from_mldev(getv(from_object, ['video']), to_object),
     )
 
   return to_object
@@ -3680,14 +3680,14 @@ def _Video_from_mldev(
     parent_object: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
-  if getv(from_object, ['video', 'uri']) is not None:
-    setv(to_object, ['uri'], getv(from_object, ['video', 'uri']))
+  if getv(from_object, ['uri']) is not None:
+    setv(to_object, ['uri'], getv(from_object, ['uri']))
 
-  if getv(from_object, ['video', 'encodedVideo']) is not None:
+  if getv(from_object, ['encodedVideo']) is not None:
     setv(
         to_object,
         ['video_bytes'],
-        base_t.t_bytes(getv(from_object, ['video', 'encodedVideo'])),
+        base_t.t_bytes(getv(from_object, ['encodedVideo'])),
     )
 
   if getv(from_object, ['encoding']) is not None:
@@ -3723,12 +3723,12 @@ def _Video_to_mldev(
 ) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['uri']) is not None:
-    setv(to_object, ['video', 'uri'], getv(from_object, ['uri']))
+    setv(to_object, ['uri'], getv(from_object, ['uri']))
 
   if getv(from_object, ['video_bytes']) is not None:
     setv(
         to_object,
-        ['video', 'encodedVideo'],
+        ['encodedVideo'],
         base_t.t_bytes(getv(from_object, ['video_bytes'])),
     )
 
@@ -5448,6 +5448,36 @@ class Models(_api_module.BaseModule):
           'Source and prompt/image/video are mutually exclusive.'
           + ' Please only use source.'
       )
+    # Gemini Developer API does not support video bytes.
+    video_dct: dict[str, Any] = {}
+    if not self._api_client.vertexai and video:
+      if isinstance(video, types.Video):
+        video_dct = video.model_dump()
+      else:
+        video_dct = dict(video)
+
+      if video_dct.get('uri') and video_dct.get('video_bytes'):
+        video = types.Video(
+            uri=video_dct.get('uri'), mime_type=video_dct.get('mime_type')
+        )
+    elif not self._api_client.vertexai and source:
+      if isinstance(source, types.GenerateVideosSource):
+        source_dct = source.model_dump()
+        video_dct = source_dct.get('video', {})
+      else:
+        source_dct = dict(source)
+        if isinstance(source_dct.get('video'), types.Video):
+          video_obj: types.Video = source_dct.get('video', types.Video())
+          video_dct = video_obj.model_dump()
+      if video_dct and video_dct.get('uri') and video_dct.get('video_bytes'):
+        source = types.GenerateVideosSource(
+            prompt=source_dct.get('prompt'),
+            image=source_dct.get('image'),
+            video=types.Video(
+                uri=video_dct.get('uri'),
+                mime_type=video_dct.get('mime_type'),
+            ),
+        )
     return self._generate_videos(
         model=model,
         prompt=prompt,

{google_genai-1.43.0 → google_genai-1.45.0}/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 @@ class Schema(_common.BaseModel):
     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 @@ class Schema(_common.BaseModel):
     # 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 @@ class Schema(_common.BaseModel):
       """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 @@ class Schema(_common.BaseModel):
       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 @@ class Schema(_common.BaseModel):
         )
 
     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 @@ class Schema(_common.BaseModel):
       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,11 +2137,14 @@ class Schema(_common.BaseModel):
       # 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,
           )
@@ -2098,17 +2152,21 @@ class Schema(_common.BaseModel):
         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,
               )
@@ -2116,20 +2174,52 @@ class Schema(_common.BaseModel):
           }
           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 @@ class FunctionDeclaration(_common.BaseModel):
             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

{google_genai-1.43.0 → google_genai-1.45.0}/google/genai/version.py

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

{google_genai-1.43.0 → google_genai-1.45.0/google_genai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.43.0
+Version: 1.45.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
@@ -279,6 +280,25 @@ http_options = types.HttpOptions(
 client=Client(..., http_options=http_options)
 ```
 
+### Custom base url
+
+In some cases you might need a custom base url (for example, API gateway proxy
+ server) and bypass some authentication checks for project, location, or API key.
+You may pass the custom base url like this:
+
+```python
+
+base_url = 'https://test-api-gateway-proxy.com'
+client = Client(
+  vertexai=True,
+  http_options={
+      'base_url': base_url,
+      'headers': {'Authorization': 'Bearer test_token'},
+  },
+)
+
+```
+
 ## Types
 
 Parameter types can be specified as either dictionaries(`TypedDict`) or

{google_genai-1.43.0 → google_genai-1.45.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel", "twine>=6.1.0", "packaging>=24.2", "pkginfo>=
 
 [project]
 name = "google-genai"
-version = "1.43.0"
+version = "1.45.0"
 description = "GenAI Python SDK"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -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"]