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

google/genai/_api_client.py

@@ -584,13 +584,9 @@ class BaseApiClient:
     # Initialize the lock. This lock will be used to protect access to the
     # credentials. This is crucial for thread safety when multiple coroutines
     # might be accessing the credentials at the same time.
-    try:
-      self._sync_auth_lock = threading.Lock()
-      self._async_auth_lock = asyncio.Lock()
-    except RuntimeError:
-      asyncio.set_event_loop(asyncio.new_event_loop())
-      self._sync_auth_lock = threading.Lock()
-      self._async_auth_lock = asyncio.Lock()
+    self._sync_auth_lock = threading.Lock()
+    self._async_auth_lock: Optional[asyncio.Lock] = None
+    self._async_auth_lock_creation_lock: Optional[asyncio.Lock] = None
 
     # Handle when to use Vertex AI in express mode (api key).
     # Explicit initializer arguments are already validated above.
@@ -903,10 +899,36 @@ class BaseApiClient:
       else:
         raise RuntimeError('Could not resolve API token from the environment')
 
+  async def _get_async_auth_lock(self) -> asyncio.Lock:
+    """Lazily initializes and returns an asyncio.Lock for async authentication.
+
+    This method ensures that a single `asyncio.Lock` instance is created and
+    shared among all asynchronous operations that require authentication,
+    preventing race conditions when accessing or refreshing credentials.
+
+    The lock is created on the first call to this method. An internal async lock
+    is used to protect the creation of the main authentication lock to ensure
+    it's a singleton within the client instance.
+
+    Returns:
+        The asyncio.Lock instance for asynchronous authentication operations.
+    """
+    if self._async_auth_lock is None:
+      # Create async creation lock if needed
+      if self._async_auth_lock_creation_lock is None:
+        self._async_auth_lock_creation_lock = asyncio.Lock()
+
+      async with self._async_auth_lock_creation_lock:
+        if self._async_auth_lock is None:
+          self._async_auth_lock = asyncio.Lock()
+
+    return self._async_auth_lock
+
   async def _async_access_token(self) -> Union[str, Any]:
     """Retrieves the access token for the credentials asynchronously."""
     if not self._credentials:
-      async with self._async_auth_lock:
+      async_auth_lock = await self._get_async_auth_lock()
+      async with async_auth_lock:
         # This ensures that only one coroutine can execute the auth logic at a
         # time for thread safety.
         if not self._credentials:
@@ -920,7 +942,8 @@ class BaseApiClient:
     if self._credentials:
       if self._credentials.expired or not self._credentials.token:
         # Only refresh when it needs to. Default expiration is 3600 seconds.
-        async with self._async_auth_lock:
+        async_auth_lock = await self._get_async_auth_lock()
+        async with async_auth_lock:
           if self._credentials.expired or not self._credentials.token:
             # Double check that the credentials expired before refreshing.
             await asyncio.to_thread(refresh_auth, self._credentials)

google/genai/_base_transformers.py

@@ -0,0 +1,26 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Base transformers for Google GenAI SDK."""
+import base64
+
+# Some fields don't accept url safe base64 encoding.
+# We shouldn't use this transformer if the backend adhere to Cloud Type
+# format https://cloud.google.com/docs/discovery/type-format.
+# TODO(b/389133914,b/390320301): Remove the hack after backend fix the issue.
+def t_bytes(data: bytes) -> str:
+  if not isinstance(data, bytes):
+    return data
+  return base64.b64encode(data).decode('ascii')

google/genai/_local_tokenizer_loader.py

@@ -0,0 +1,223 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+import dataclasses
+import functools
+import hashlib
+import os
+import tempfile
+from typing import Optional, cast
+import uuid
+
+import requests  # type: ignore
+import sentencepiece as spm
+from sentencepiece import sentencepiece_model_pb2
+
+
+# Source of truth: https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models
+_GEMINI_MODELS_TO_TOKENIZER_NAMES = {
+    "gemini-1.0-pro": "gemma2",
+    "gemini-1.5-pro": "gemma2",
+    "gemini-1.5-flash": "gemma2",
+    "gemini-2.5-pro": "gemma3",
+    "gemini-2.5-flash": "gemma3",
+    "gemini-2.5-flash-lite": "gemma3",
+    "gemini-2.0-flash": "gemma3",
+    "gemini-2.0-flash-lite": "gemma3",
+}
+_GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES = {
+    "gemini-1.0-pro-001": "gemma2",
+    "gemini-1.0-pro-002": "gemma2",
+    "gemini-1.5-pro-001": "gemma2",
+    "gemini-1.5-flash-001": "gemma2",
+    "gemini-1.5-flash-002": "gemma2",
+    "gemini-1.5-pro-002": "gemma2",
+    "gemini-2.5-pro-preview-06-05": "gemma3",
+    "gemini-2.5-pro-preview-05-06": "gemma3",
+    "gemini-2.5-pro-exp-03-25": "gemma3",
+    "gemini-live-2.5-flash": "gemma3",
+    "gemini-2.5-flash-preview-05-20": "gemma3",
+    "gemini-2.5-flash-preview-04-17": "gemma3",
+    "gemini-2.5-flash-lite-preview-06-17": "gemma3",
+    "gemini-2.0-flash-001": "gemma3",
+    "gemini-2.0-flash-lite-001": "gemma3",
+}
+
+
+@dataclasses.dataclass(frozen=True)
+class _TokenizerConfig:
+  model_url: str
+  model_hash: str
+
+
+# TODO: update gemma3 tokenizer
+_TOKENIZERS = {
+    "gemma2": _TokenizerConfig(
+        model_url="https://raw.githubusercontent.com/google/gemma_pytorch/33b652c465537c6158f9a472ea5700e5e770ad3f/tokenizer/tokenizer.model",
+        model_hash=(
+            "61a7b147390c64585d6c3543dd6fc636906c9af3865a5548f27f31aee1d4c8e2"
+        ),
+    ),
+    "gemma3": _TokenizerConfig(
+        model_url="https://raw.githubusercontent.com/google/gemma_pytorch/014acb7ac4563a5f77c76d7ff98f31b568c16508/tokenizer/gemma3_cleaned_262144_v2.spiece.model",
+        model_hash=(
+            "1299c11d7cf632ef3b4e11937501358ada021bbdf7c47638d13c0ee982f2e79c"
+        ),
+    ),
+}
+
+
+def _load_file(file_url_path: str) -> bytes:
+  """Loads file bytes from the given file url path."""
+  resp = requests.get(file_url_path)
+  resp.raise_for_status()
+  return cast(bytes, resp.content)
+
+
+def _is_valid_model(*, model_data: bytes, expected_hash: str) -> bool:
+  """Returns true if the content is valid by checking the hash."""
+  if not expected_hash:
+    raise ValueError("expected_hash is required")
+  return hashlib.sha256(model_data).hexdigest() == expected_hash
+
+
+def _maybe_remove_file(file_path: str) -> None:
+  """Removes the file if exists."""
+  if not os.path.exists(file_path):
+    return
+  try:
+    os.remove(file_path)
+  except OSError:
+    # Don't raise if we cannot remove file.
+    pass
+
+
+def _maybe_load_from_cache(
+    *, file_path: str, expected_hash: str
+) -> Optional[bytes]:
+  """Loads the content from the cache path."""
+  if not os.path.exists(file_path):
+    return None
+  with open(file_path, "rb") as f:
+    content = f.read()
+  if _is_valid_model(model_data=content, expected_hash=expected_hash):
+    return content
+
+  # Cached file corrupted.
+  _maybe_remove_file(file_path)
+  return None
+
+
+def _maybe_save_to_cache(
+    *, cache_dir: str, cache_path: str, content: bytes
+) -> None:
+  """Saves the content to the cache path."""
+  try:
+    os.makedirs(cache_dir, exist_ok=True)
+    tmp_path = cache_dir + "." + str(uuid.uuid4()) + ".tmp"
+    with open(tmp_path, "wb") as f:
+      f.write(content)
+    os.rename(tmp_path, cache_path)
+  except OSError:
+    # Don't raise if we cannot write file.
+    pass
+
+
+def _load_from_url(*, file_url: str, expected_hash: str) -> bytes:
+  """Loads model bytes from the given file url."""
+  content = _load_file(file_url)
+  if not _is_valid_model(model_data=content, expected_hash=expected_hash):
+    actual_hash = hashlib.sha256(content).hexdigest()
+    raise ValueError(
+        "Downloaded model file is corrupted."
+        f" Expected hash {expected_hash}. Got file hash {actual_hash}."
+    )
+  return content
+
+
+def _load(*, file_url: str, expected_hash: str) -> bytes:
+  """Loads model bytes from the given file url.
+
+  1. If the find local cached file for the given url and the cached file hash
+     matches the expected hash, the cached file is returned.
+  2. If local cached file is not found or the hash does not match, the file is
+     downloaded from the given url. And write to local cache and return the
+     file bytes.
+  3. If the file downloaded from the given url does not match the expected
+     hash, raise ValueError.
+
+  Args:
+      file_url: The url of the file to load.
+      expected_hash: The expected hash of the file.
+
+  Returns:
+      The file bytes.
+  """
+  model_dir = os.path.join(tempfile.gettempdir(), "vertexai_tokenizer_model")
+  filename = hashlib.sha1(file_url.encode()).hexdigest()
+  model_path = os.path.join(model_dir, filename)
+
+  model_data = _maybe_load_from_cache(
+      file_path=model_path, expected_hash=expected_hash
+  )
+  if not model_data:
+    model_data = _load_from_url(file_url=file_url, expected_hash=expected_hash)
+
+  _maybe_save_to_cache(
+      cache_dir=model_dir, cache_path=model_path, content=model_data
+  )
+  return model_data
+
+
+def _load_model_proto_bytes(tokenizer_name: str) -> bytes:
+  """Loads model proto bytes from the given tokenizer name."""
+  if tokenizer_name not in _TOKENIZERS:
+    raise ValueError(
+        f"Tokenizer {tokenizer_name} is not supported."
+        f"Supported tokenizers: {list(_TOKENIZERS.keys())}"
+    )
+  return _load(
+      file_url=_TOKENIZERS[tokenizer_name].model_url,
+      expected_hash=_TOKENIZERS[tokenizer_name].model_hash,
+  )
+
+
+@functools.lru_cache()
+def load_model_proto(
+    tokenizer_name: str,
+) -> sentencepiece_model_pb2.ModelProto:
+  """Loads model proto from the given tokenizer name."""
+  model_proto = sentencepiece_model_pb2.ModelProto()
+  model_proto.ParseFromString(_load_model_proto_bytes(tokenizer_name))
+  return model_proto
+
+
+def get_tokenizer_name(model_name: str) -> str:
+  """Gets the tokenizer name for the given model name."""
+  if model_name in _GEMINI_MODELS_TO_TOKENIZER_NAMES.keys():
+    return _GEMINI_MODELS_TO_TOKENIZER_NAMES[model_name]
+  if model_name in _GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES.keys():
+    return _GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES[model_name]
+  raise ValueError(
+      f"Model {model_name} is not supported. Supported models: {', '.join(_GEMINI_MODELS_TO_TOKENIZER_NAMES.keys())}, {', '.join(_GEMINI_STABLE_MODELS_TO_TOKENIZER_NAMES.keys())}.\n"  # pylint: disable=line-too-long
+  )
+
+
+@functools.lru_cache()
+def get_sentencepiece(tokenizer_name: str) -> spm.SentencePieceProcessor:
+  """Loads sentencepiece tokenizer from the given tokenizer name."""
+  processor = spm.SentencePieceProcessor()
+  processor.LoadFromSerializedProto(_load_model_proto_bytes(tokenizer_name))
+  return processor

google/genai/_operations_converters.py

@@ -0,0 +1,307 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Code generated by the Google Gen AI SDK generator DO NOT EDIT.
+
+from typing import Any, Optional, Union
+from . import _base_transformers as base_t
+from ._common import get_value_by_path as getv
+from ._common import set_value_by_path as setv
+
+
+def _FetchPredictOperationParameters_to_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['operation_name']) is not None:
+    raise ValueError('operation_name parameter is not supported in Gemini API.')
+
+  if getv(from_object, ['resource_name']) is not None:
+    raise ValueError('resource_name parameter is not supported in Gemini API.')
+
+  if getv(from_object, ['config']) is not None:
+    raise ValueError('config parameter is not supported in Gemini API.')
+
+  return to_object
+
+
+def _GetOperationParameters_to_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['operation_name']) is not None:
+    setv(
+        to_object,
+        ['_url', 'operationName'],
+        getv(from_object, ['operation_name']),
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _FetchPredictOperationParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['operation_name']) is not None:
+    setv(to_object, ['operationName'], getv(from_object, ['operation_name']))
+
+  if getv(from_object, ['resource_name']) is not None:
+    setv(
+        to_object,
+        ['_url', 'resourceName'],
+        getv(from_object, ['resource_name']),
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _GetOperationParameters_to_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['operation_name']) is not None:
+    setv(
+        to_object,
+        ['_url', 'operationName'],
+        getv(from_object, ['operation_name']),
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _Video_from_mldev(
+    from_object: Union[dict[str, Any], object],
+    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, ['video', 'encodedVideo']) is not None:
+    setv(
+        to_object,
+        ['video_bytes'],
+        base_t.t_bytes(getv(from_object, ['video', 'encodedVideo'])),
+    )
+
+  if getv(from_object, ['encoding']) is not None:
+    setv(to_object, ['mime_type'], getv(from_object, ['encoding']))
+
+  return to_object
+
+
+def _GeneratedVideo_from_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['_self']) is not None:
+    setv(
+        to_object,
+        ['video'],
+        _Video_from_mldev(getv(from_object, ['_self']), to_object),
+    )
+
+  return to_object
+
+
+def _GenerateVideosResponse_from_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['generatedSamples']) is not None:
+    setv(
+        to_object,
+        ['generated_videos'],
+        [
+            _GeneratedVideo_from_mldev(item, to_object)
+            for item in getv(from_object, ['generatedSamples'])
+        ],
+    )
+
+  if getv(from_object, ['raiMediaFilteredCount']) is not None:
+    setv(
+        to_object,
+        ['rai_media_filtered_count'],
+        getv(from_object, ['raiMediaFilteredCount']),
+    )
+
+  if getv(from_object, ['raiMediaFilteredReasons']) is not None:
+    setv(
+        to_object,
+        ['rai_media_filtered_reasons'],
+        getv(from_object, ['raiMediaFilteredReasons']),
+    )
+
+  return to_object
+
+
+def _GenerateVideosOperation_from_mldev(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['name']) is not None:
+    setv(to_object, ['name'], getv(from_object, ['name']))
+
+  if getv(from_object, ['metadata']) is not None:
+    setv(to_object, ['metadata'], getv(from_object, ['metadata']))
+
+  if getv(from_object, ['done']) is not None:
+    setv(to_object, ['done'], getv(from_object, ['done']))
+
+  if getv(from_object, ['error']) is not None:
+    setv(to_object, ['error'], getv(from_object, ['error']))
+
+  if getv(from_object, ['response', 'generateVideoResponse']) is not None:
+    setv(
+        to_object,
+        ['response'],
+        _GenerateVideosResponse_from_mldev(
+            getv(from_object, ['response', 'generateVideoResponse']), to_object
+        ),
+    )
+
+  if getv(from_object, ['response', 'generateVideoResponse']) is not None:
+    setv(
+        to_object,
+        ['result'],
+        _GenerateVideosResponse_from_mldev(
+            getv(from_object, ['response', 'generateVideoResponse']), to_object
+        ),
+    )
+
+  return to_object
+
+
+def _Video_from_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['gcsUri']) is not None:
+    setv(to_object, ['uri'], getv(from_object, ['gcsUri']))
+
+  if getv(from_object, ['bytesBase64Encoded']) is not None:
+    setv(
+        to_object,
+        ['video_bytes'],
+        base_t.t_bytes(getv(from_object, ['bytesBase64Encoded'])),
+    )
+
+  if getv(from_object, ['mimeType']) is not None:
+    setv(to_object, ['mime_type'], getv(from_object, ['mimeType']))
+
+  return to_object
+
+
+def _GeneratedVideo_from_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['_self']) is not None:
+    setv(
+        to_object,
+        ['video'],
+        _Video_from_vertex(getv(from_object, ['_self']), to_object),
+    )
+
+  return to_object
+
+
+def _GenerateVideosResponse_from_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['videos']) is not None:
+    setv(
+        to_object,
+        ['generated_videos'],
+        [
+            _GeneratedVideo_from_vertex(item, to_object)
+            for item in getv(from_object, ['videos'])
+        ],
+    )
+
+  if getv(from_object, ['raiMediaFilteredCount']) is not None:
+    setv(
+        to_object,
+        ['rai_media_filtered_count'],
+        getv(from_object, ['raiMediaFilteredCount']),
+    )
+
+  if getv(from_object, ['raiMediaFilteredReasons']) is not None:
+    setv(
+        to_object,
+        ['rai_media_filtered_reasons'],
+        getv(from_object, ['raiMediaFilteredReasons']),
+    )
+
+  return to_object
+
+
+def _GenerateVideosOperation_from_vertex(
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['name']) is not None:
+    setv(to_object, ['name'], getv(from_object, ['name']))
+
+  if getv(from_object, ['metadata']) is not None:
+    setv(to_object, ['metadata'], getv(from_object, ['metadata']))
+
+  if getv(from_object, ['done']) is not None:
+    setv(to_object, ['done'], getv(from_object, ['done']))
+
+  if getv(from_object, ['error']) is not None:
+    setv(to_object, ['error'], getv(from_object, ['error']))
+
+  if getv(from_object, ['response']) is not None:
+    setv(
+        to_object,
+        ['response'],
+        _GenerateVideosResponse_from_vertex(
+            getv(from_object, ['response']), to_object
+        ),
+    )
+
+  if getv(from_object, ['response']) is not None:
+    setv(
+        to_object,
+        ['result'],
+        _GenerateVideosResponse_from_vertex(
+            getv(from_object, ['response']), to_object
+        ),
+    )
+
+  return to_object

google/genai/_replay_api_client.py

@@ -471,6 +471,21 @@ class ReplayApiClient(BaseApiClient):
     expected = interaction.response.sdk_response_segments[
         self._sdk_response_index
     ]
+    # The sdk_http_response.body has format in the string, need to get rid of
+    # the format information before comparing.
+    if isinstance(expected, dict):
+      if 'sdk_http_response' in expected and isinstance(
+          expected['sdk_http_response'], dict
+      ):
+        if 'body' in expected['sdk_http_response']:
+          raw_body = expected['sdk_http_response']['body']
+          print('raw_body length: ', len(raw_body))
+          print('raw_body: ', raw_body)
+          if isinstance(raw_body, str) and raw_body != '':
+            raw_body = json.loads(raw_body)
+            raw_body = json.dumps(raw_body)
+            expected['sdk_http_response']['body'] = raw_body
+
     assert (
         actual == expected
     ), f'SDK response mismatch:\nActual: {actual}\nExpected: {expected}'

google/genai/_transformers.py

@@ -1156,16 +1156,6 @@ def t_tuning_job_status(status: str) -> Union[types.JobState, str]:
     return status
 
 
-# Some fields don't accept url safe base64 encoding.
-# We shouldn't use this transformer if the backend adhere to Cloud Type
-# format https://cloud.google.com/docs/discovery/type-format.
-# TODO(b/389133914,b/390320301): Remove the hack after backend fix the issue.
-def t_bytes(data: bytes) -> str:
-  if not isinstance(data, bytes):
-    return data
-  return base64.b64encode(data).decode('ascii')
-
-
 def t_content_strict(content: types.ContentOrDict) -> types.Content:
   if isinstance(content, dict):
     return types.Content.model_validate(content)