sarvamai 0.1.23a3__py3-none-any.whl → 0.1.23a5__py3-none-any.whl

sarvamai/core/http_client.py

@@ -5,6 +5,7 @@ import email.utils
 import re
 import time
 import typing
+import urllib.parse
 from contextlib import asynccontextmanager, contextmanager
 from random import random
 
@@ -13,13 +14,13 @@ from .file import File, convert_file_dict_to_httpx_tuples
 from .force_multipart import FORCE_MULTIPART
 from .jsonable_encoder import jsonable_encoder
 from .query_encoder import encode_query
-from .remove_none_from_dict import remove_none_from_dict as remove_none_from_dict
+from .remove_none_from_dict import remove_none_from_dict
 from .request_options import RequestOptions
 from httpx._types import RequestFiles
 
-INITIAL_RETRY_DELAY_SECONDS = 1.0
-MAX_RETRY_DELAY_SECONDS = 60.0
-JITTER_FACTOR = 0.2  # 20% random jitter
+INITIAL_RETRY_DELAY_SECONDS = 0.5
+MAX_RETRY_DELAY_SECONDS = 10
+MAX_RETRY_DELAY_SECONDS_FROM_HEADER = 30
 
 
 def _parse_retry_after(response_headers: httpx.Headers) -> typing.Optional[float]:
@@ -63,38 +64,6 @@ def _parse_retry_after(response_headers: httpx.Headers) -> typing.Optional[float
     return seconds
 
 
-def _add_positive_jitter(delay: float) -> float:
-    """Add positive jitter (0-20%) to prevent thundering herd."""
-    jitter_multiplier = 1 + random() * JITTER_FACTOR
-    return delay * jitter_multiplier
-
-
-def _add_symmetric_jitter(delay: float) -> float:
-    """Add symmetric jitter (±10%) for exponential backoff."""
-    jitter_multiplier = 1 + (random() - 0.5) * JITTER_FACTOR
-    return delay * jitter_multiplier
-
-
-def _parse_x_ratelimit_reset(response_headers: httpx.Headers) -> typing.Optional[float]:
-    """
-    Parse the X-RateLimit-Reset header (Unix timestamp in seconds).
-    Returns seconds to wait, or None if header is missing/invalid.
-    """
-    reset_time_str = response_headers.get("x-ratelimit-reset")
-    if reset_time_str is None:
-        return None
-
-    try:
-        reset_time = int(reset_time_str)
-        delay = reset_time - time.time()
-        if delay > 0:
-            return delay
-    except (ValueError, TypeError):
-        pass
-
-    return None
-
-
 def _retry_timeout(response: httpx.Response, retries: int) -> float:
     """
     Determine the amount of time to wait before retrying a request.
@@ -102,19 +71,17 @@ def _retry_timeout(response: httpx.Response, retries: int) -> float:
     with a jitter to determine the number of seconds to wait.
     """
 
-    # 1. Check Retry-After header first
+    # If the API asks us to wait a certain amount of time (and it's a reasonable amount), just do what it says.
     retry_after = _parse_retry_after(response.headers)
-    if retry_after is not None and retry_after > 0:
-        return min(retry_after, MAX_RETRY_DELAY_SECONDS)
+    if retry_after is not None and retry_after <= MAX_RETRY_DELAY_SECONDS_FROM_HEADER:
+        return retry_after
 
-    # 2. Check X-RateLimit-Reset header (with positive jitter)
-    ratelimit_reset = _parse_x_ratelimit_reset(response.headers)
-    if ratelimit_reset is not None:
-        return _add_positive_jitter(min(ratelimit_reset, MAX_RETRY_DELAY_SECONDS))
+    # Apply exponential backoff, capped at MAX_RETRY_DELAY_SECONDS.
+    retry_delay = min(INITIAL_RETRY_DELAY_SECONDS * pow(2.0, retries), MAX_RETRY_DELAY_SECONDS)
 
-    # 3. Fall back to exponential backoff (with symmetric jitter)
-    backoff = min(INITIAL_RETRY_DELAY_SECONDS * pow(2.0, retries), MAX_RETRY_DELAY_SECONDS)
-    return _add_symmetric_jitter(backoff)
+    # Add a randomness / jitter to the retry delay to avoid overwhelming the server with retries.
+    timeout = retry_delay * (1 - 0.25 * random())
+    return timeout if timeout >= 0 else 0
 
 
 def _should_retry(response: httpx.Response) -> bool:
@@ -122,45 +89,6 @@ def _should_retry(response: httpx.Response) -> bool:
     return response.status_code >= 500 or response.status_code in retryable_400s
 
 
-def _build_url(base_url: str, path: typing.Optional[str]) -> str:
-    """
-    Build a full URL by joining a base URL with a path.
-
-    This function correctly handles base URLs that contain path prefixes (e.g., tenant-based URLs)
-    by using string concatenation instead of urllib.parse.urljoin(), which would incorrectly
-    strip path components when the path starts with '/'.
-
-    Example:
-        >>> _build_url("https://cloud.example.com/org/tenant/api", "/users")
-        'https://cloud.example.com/org/tenant/api/users'
-
-    Args:
-        base_url: The base URL, which may contain path prefixes.
-        path: The path to append. Can be None or empty string.
-
-    Returns:
-        The full URL with base_url and path properly joined.
-    """
-    if not path:
-        return base_url
-    return f"{base_url.rstrip('/')}/{path.lstrip('/')}"
-
-
-def _maybe_filter_none_from_multipart_data(
-    data: typing.Optional[typing.Any],
-    request_files: typing.Optional[RequestFiles],
-    force_multipart: typing.Optional[bool],
-) -> typing.Optional[typing.Any]:
-    """
-    Filter None values from data body for multipart/form requests.
-    This prevents httpx from converting None to empty strings in multipart encoding.
-    Only applies when files are present or force_multipart is True.
-    """
-    if data is not None and isinstance(data, typing.Mapping) and (request_files or force_multipart):
-        return remove_none_from_dict(data)
-    return data
-
-
 def remove_omit_from_dict(
     original: typing.Dict[str, typing.Optional[typing.Any]],
     omit: typing.Optional[typing.Any],
@@ -215,19 +143,8 @@ def get_request_body(
         # If both data and json are None, we send json data in the event extra properties are specified
         json_body = maybe_filter_request_body(json, request_options, omit)
 
-    has_additional_body_parameters = bool(
-        request_options is not None and request_options.get("additional_body_parameters")
-    )
-
-    # Only collapse empty dict to None when the body was not explicitly provided
-    # and there are no additional body parameters. This preserves explicit empty
-    # bodies (e.g., when an endpoint has a request body type but all fields are optional).
-    if json_body == {} and json is None and not has_additional_body_parameters:
-        json_body = None
-    if data_body == {} and data is None and not has_additional_body_parameters:
-        data_body = None
-
-    return json_body, data_body
+    # If you have an empty JSON body, you should just send None
+    return (json_body if json_body != {} else None), data_body if data_body != {} else None
 
 
 class HttpClient:
@@ -271,7 +188,7 @@ class HttpClient:
         ] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
-        retries: int = 0,
+        retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
         force_multipart: typing.Optional[bool] = None,
     ) -> httpx.Response:
@@ -293,31 +210,9 @@ class HttpClient:
         if (request_files is None or len(request_files) == 0) and force_multipart:
             request_files = FORCE_MULTIPART
 
-        data_body = _maybe_filter_none_from_multipart_data(data_body, request_files, force_multipart)
-
-        # Compute encoded params separately to avoid passing empty list to httpx
-        # (httpx strips existing query params from URL when params=[] is passed)
-        _encoded_params = encode_query(
-            jsonable_encoder(
-                remove_none_from_dict(
-                    remove_omit_from_dict(
-                        {
-                            **(params if params is not None else {}),
-                            **(
-                                request_options.get("additional_query_parameters", {}) or {}
-                                if request_options is not None
-                                else {}
-                            ),
-                        },
-                        omit,
-                    )
-                )
-            )
-        )
-
         response = self.httpx_client.request(
             method=method,
-            url=_build_url(base_url, path),
+            url=urllib.parse.urljoin(f"{base_url}/", path),
             headers=jsonable_encoder(
                 remove_none_from_dict(
                     {
@@ -327,7 +222,23 @@ class HttpClient:
                     }
                 )
             ),
-            params=_encoded_params if _encoded_params else None,
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {}) or {}
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit,
+                        )
+                    )
+                )
+            ),
             json=json_body,
             data=data_body,
             content=content,
@@ -335,9 +246,9 @@ class HttpClient:
             timeout=timeout,
         )
 
-        max_retries: int = request_options.get("max_retries", 2) if request_options is not None else 2
+        max_retries: int = request_options.get("max_retries", 0) if request_options is not None else 0
         if _should_retry(response=response):
-            if retries < max_retries:
+            if max_retries > retries:
                 time.sleep(_retry_timeout(response=response, retries=retries))
                 return self.request(
                     path=path,
@@ -374,7 +285,7 @@ class HttpClient:
         ] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
-        retries: int = 0,
+        retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
         force_multipart: typing.Optional[bool] = None,
     ) -> typing.Iterator[httpx.Response]:
@@ -396,31 +307,9 @@ class HttpClient:
 
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
-        data_body = _maybe_filter_none_from_multipart_data(data_body, request_files, force_multipart)
-
-        # Compute encoded params separately to avoid passing empty list to httpx
-        # (httpx strips existing query params from URL when params=[] is passed)
-        _encoded_params = encode_query(
-            jsonable_encoder(
-                remove_none_from_dict(
-                    remove_omit_from_dict(
-                        {
-                            **(params if params is not None else {}),
-                            **(
-                                request_options.get("additional_query_parameters", {})
-                                if request_options is not None
-                                else {}
-                            ),
-                        },
-                        omit,
-                    )
-                )
-            )
-        )
-
         with self.httpx_client.stream(
             method=method,
-            url=_build_url(base_url, path),
+            url=urllib.parse.urljoin(f"{base_url}/", path),
             headers=jsonable_encoder(
                 remove_none_from_dict(
                     {
@@ -430,7 +319,23 @@ class HttpClient:
                     }
                 )
             ),
-            params=_encoded_params if _encoded_params else None,
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {})
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit,
+                        )
+                    )
+                )
+            ),
             json=json_body,
             data=data_body,
             content=content,
@@ -448,19 +353,12 @@ class AsyncHttpClient:
         base_timeout: typing.Callable[[], typing.Optional[float]],
         base_headers: typing.Callable[[], typing.Dict[str, str]],
         base_url: typing.Optional[typing.Callable[[], str]] = None,
-        async_base_headers: typing.Optional[typing.Callable[[], typing.Awaitable[typing.Dict[str, str]]]] = None,
     ):
         self.base_url = base_url
         self.base_timeout = base_timeout
         self.base_headers = base_headers
-        self.async_base_headers = async_base_headers
         self.httpx_client = httpx_client
 
-    async def _get_headers(self) -> typing.Dict[str, str]:
-        if self.async_base_headers is not None:
-            return await self.async_base_headers()
-        return self.base_headers()
-
     def get_base_url(self, maybe_base_url: typing.Optional[str]) -> str:
         base_url = maybe_base_url
         if self.base_url is not None and base_url is None:
@@ -488,7 +386,7 @@ class AsyncHttpClient:
         ] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
-        retries: int = 0,
+        retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
         force_multipart: typing.Optional[bool] = None,
     ) -> httpx.Response:
@@ -510,45 +408,36 @@ class AsyncHttpClient:
 
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
-        data_body = _maybe_filter_none_from_multipart_data(data_body, request_files, force_multipart)
-
-        # Get headers (supports async token providers)
-        _headers = await self._get_headers()
-
-        # Compute encoded params separately to avoid passing empty list to httpx
-        # (httpx strips existing query params from URL when params=[] is passed)
-        _encoded_params = encode_query(
-            jsonable_encoder(
-                remove_none_from_dict(
-                    remove_omit_from_dict(
-                        {
-                            **(params if params is not None else {}),
-                            **(
-                                request_options.get("additional_query_parameters", {}) or {}
-                                if request_options is not None
-                                else {}
-                            ),
-                        },
-                        omit,
-                    )
-                )
-            )
-        )
-
         # Add the input to each of these and do None-safety checks
         response = await self.httpx_client.request(
             method=method,
-            url=_build_url(base_url, path),
+            url=urllib.parse.urljoin(f"{base_url}/", path),
             headers=jsonable_encoder(
                 remove_none_from_dict(
                     {
-                        **_headers,
+                        **self.base_headers(),
                         **(headers if headers is not None else {}),
                         **(request_options.get("additional_headers", {}) or {} if request_options is not None else {}),
                     }
                 )
             ),
-            params=_encoded_params if _encoded_params else None,
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {}) or {}
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit,
+                        )
+                    )
+                )
+            ),
             json=json_body,
             data=data_body,
             content=content,
@@ -556,9 +445,9 @@ class AsyncHttpClient:
             timeout=timeout,
         )
 
-        max_retries: int = request_options.get("max_retries", 2) if request_options is not None else 2
+        max_retries: int = request_options.get("max_retries", 0) if request_options is not None else 0
         if _should_retry(response=response):
-            if retries < max_retries:
+            if max_retries > retries:
                 await asyncio.sleep(_retry_timeout(response=response, retries=retries))
                 return await self.request(
                     path=path,
@@ -594,7 +483,7 @@ class AsyncHttpClient:
         ] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
-        retries: int = 0,
+        retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
         force_multipart: typing.Optional[bool] = None,
     ) -> typing.AsyncIterator[httpx.Response]:
@@ -616,44 +505,35 @@ class AsyncHttpClient:
 
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
-        data_body = _maybe_filter_none_from_multipart_data(data_body, request_files, force_multipart)
-
-        # Get headers (supports async token providers)
-        _headers = await self._get_headers()
-
-        # Compute encoded params separately to avoid passing empty list to httpx
-        # (httpx strips existing query params from URL when params=[] is passed)
-        _encoded_params = encode_query(
-            jsonable_encoder(
-                remove_none_from_dict(
-                    remove_omit_from_dict(
-                        {
-                            **(params if params is not None else {}),
-                            **(
-                                request_options.get("additional_query_parameters", {})
-                                if request_options is not None
-                                else {}
-                            ),
-                        },
-                        omit=omit,
-                    )
-                )
-            )
-        )
-
         async with self.httpx_client.stream(
             method=method,
-            url=_build_url(base_url, path),
+            url=urllib.parse.urljoin(f"{base_url}/", path),
             headers=jsonable_encoder(
                 remove_none_from_dict(
                     {
-                        **_headers,
+                        **self.base_headers(),
                         **(headers if headers is not None else {}),
                         **(request_options.get("additional_headers", {}) if request_options is not None else {}),
                     }
                 )
             ),
-            params=_encoded_params if _encoded_params else None,
+            params=encode_query(
+                jsonable_encoder(
+                    remove_none_from_dict(
+                        remove_omit_from_dict(
+                            {
+                                **(params if params is not None else {}),
+                                **(
+                                    request_options.get("additional_query_parameters", {})
+                                    if request_options is not None
+                                    else {}
+                                ),
+                            },
+                            omit=omit,
+                        )
+                    )
+                )
+            ),
             json=json_body,
             data=data_body,
             content=content,

sarvamai/core/http_response.py

@@ -4,8 +4,8 @@ from typing import Dict, Generic, TypeVar
 
 import httpx
 
-# Generic to represent the underlying type of the data wrapped by the HTTP response.
 T = TypeVar("T")
+"""Generic to represent the underlying type of the data wrapped by the HTTP response."""
 
 
 class BaseHttpResponse:

sarvamai/core/jsonable_encoder.py

@@ -30,10 +30,6 @@ DictIntStrAny = Dict[Union[int, str], Any]
 
 def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
     custom_encoder = custom_encoder or {}
-    # Generated SDKs use Ellipsis (`...`) as the sentinel value for "OMIT".
-    # OMIT values should be excluded from serialized payloads.
-    if obj is Ellipsis:
-        return None
     if custom_encoder:
         if type(obj) in custom_encoder:
             return custom_encoder[type(obj)](obj)
@@ -74,8 +70,6 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
         allowed_keys = set(obj.keys())
         for key, value in obj.items():
             if key in allowed_keys:
-                if value is Ellipsis:
-                    continue
                 encoded_key = jsonable_encoder(key, custom_encoder=custom_encoder)
                 encoded_value = jsonable_encoder(value, custom_encoder=custom_encoder)
                 encoded_dict[encoded_key] = encoded_value
@@ -83,8 +77,6 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
     if isinstance(obj, (list, set, frozenset, GeneratorType, tuple)):
         encoded_list = []
         for item in obj:
-            if item is Ellipsis:
-                continue
             encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
         return encoded_list
 

sarvamai/core/pydantic_utilities.py

@@ -2,7 +2,6 @@
 
 # nopycln: file
 import datetime as dt
-import inspect
 from collections import defaultdict
 from typing import Any, Callable, ClassVar, Dict, List, Mapping, Optional, Set, Tuple, Type, TypeVar, Union, cast
 
@@ -38,36 +37,7 @@ Model = TypeVar("Model", bound=pydantic.BaseModel)
 
 
 def parse_obj_as(type_: Type[T], object_: Any) -> T:
-    # convert_and_respect_annotation_metadata is required for TypedDict aliasing.
-    #
-    # For Pydantic models, whether we should pre-dealias depends on how the model encodes aliasing:
-    # - If the model uses real Pydantic aliases (pydantic.Field(alias=...)), then we must pass wire keys through
-    #   unchanged so Pydantic can validate them.
-    # - If the model encodes aliasing only via FieldMetadata annotations, then we MUST pre-dealias because Pydantic
-    #   will not recognize those aliases during validation.
-    if inspect.isclass(type_) and issubclass(type_, pydantic.BaseModel):
-        has_pydantic_aliases = False
-        if IS_PYDANTIC_V2:
-            for field_name, field_info in getattr(type_, "model_fields", {}).items():  # type: ignore[attr-defined]
-                alias = getattr(field_info, "alias", None)
-                if alias is not None and alias != field_name:
-                    has_pydantic_aliases = True
-                    break
-        else:
-            for field in getattr(type_, "__fields__", {}).values():
-                alias = getattr(field, "alias", None)
-                name = getattr(field, "name", None)
-                if alias is not None and name is not None and alias != name:
-                    has_pydantic_aliases = True
-                    break
-
-        dealiased_object = (
-            object_
-            if has_pydantic_aliases
-            else convert_and_respect_annotation_metadata(object_=object_, annotation=type_, direction="read")
-        )
-    else:
-        dealiased_object = convert_and_respect_annotation_metadata(object_=object_, annotation=type_, direction="read")
+    dealiased_object = convert_and_respect_annotation_metadata(object_=object_, annotation=type_, direction="read")
     if IS_PYDANTIC_V2:
         adapter = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
         return adapter.validate_python(dealiased_object)
@@ -89,46 +59,9 @@ class UniversalBaseModel(pydantic.BaseModel):
             protected_namespaces=(),
         )
 
-        @pydantic.model_validator(mode="before")  # type: ignore[attr-defined]
-        @classmethod
-        def _coerce_field_names_to_aliases(cls, data: Any) -> Any:
-            """
-            Accept Python field names in input by rewriting them to their Pydantic aliases,
-            while avoiding silent collisions when a key could refer to multiple fields.
-            """
-            if not isinstance(data, Mapping):
-                return data
-
-            fields = getattr(cls, "model_fields", {})  # type: ignore[attr-defined]
-            name_to_alias: Dict[str, str] = {}
-            alias_to_name: Dict[str, str] = {}
-
-            for name, field_info in fields.items():
-                alias = getattr(field_info, "alias", None) or name
-                name_to_alias[name] = alias
-                if alias != name:
-                    alias_to_name[alias] = name
-
-            # Detect ambiguous keys: a key that is an alias for one field and a name for another.
-            ambiguous_keys = set(alias_to_name.keys()).intersection(set(name_to_alias.keys()))
-            for key in ambiguous_keys:
-                if key in data and name_to_alias[key] not in data:
-                    raise ValueError(
-                        f"Ambiguous input key '{key}': it is both a field name and an alias. "
-                        "Provide the explicit alias key to disambiguate."
-                    )
-
-            original_keys = set(data.keys())
-            rewritten: Dict[str, Any] = dict(data)
-            for name, alias in name_to_alias.items():
-                if alias != name and name in original_keys and alias not in rewritten:
-                    rewritten[alias] = rewritten.pop(name)
-
-            return rewritten
-
         @pydantic.model_serializer(mode="plain", when_used="json")  # type: ignore[attr-defined]
         def serialize_model(self) -> Any:  # type: ignore[name-defined]
-            serialized = self.dict()  # type: ignore[attr-defined]
+            serialized = self.model_dump()
             data = {k: serialize_datetime(v) if isinstance(v, dt.datetime) else v for k, v in serialized.items()}
             return data
 
@@ -138,40 +71,6 @@ class UniversalBaseModel(pydantic.BaseModel):
             smart_union = True
             json_encoders = {dt.datetime: serialize_datetime}
 
-        @pydantic.root_validator(pre=True)
-        def _coerce_field_names_to_aliases(cls, values: Any) -> Any:
-            """
-            Pydantic v1 equivalent of _coerce_field_names_to_aliases.
-            """
-            if not isinstance(values, Mapping):
-                return values
-
-            fields = getattr(cls, "__fields__", {})
-            name_to_alias: Dict[str, str] = {}
-            alias_to_name: Dict[str, str] = {}
-
-            for name, field in fields.items():
-                alias = getattr(field, "alias", None) or name
-                name_to_alias[name] = alias
-                if alias != name:
-                    alias_to_name[alias] = name
-
-            ambiguous_keys = set(alias_to_name.keys()).intersection(set(name_to_alias.keys()))
-            for key in ambiguous_keys:
-                if key in values and name_to_alias[key] not in values:
-                    raise ValueError(
-                        f"Ambiguous input key '{key}': it is both a field name and an alias. "
-                        "Provide the explicit alias key to disambiguate."
-                    )
-
-            original_keys = set(values.keys())
-            rewritten: Dict[str, Any] = dict(values)
-            for name, alias in name_to_alias.items():
-                if alias != name and name in original_keys and alias not in rewritten:
-                    rewritten[alias] = rewritten.pop(name)
-
-            return rewritten
-
     @classmethod
     def model_construct(cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any) -> "Model":
         dealiased_object = convert_and_respect_annotation_metadata(object_=values, annotation=cls, direction="read")
@@ -248,10 +147,7 @@ class UniversalBaseModel(pydantic.BaseModel):
 
             dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
 
-        return cast(
-            Dict[str, Any],
-            convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write"),
-        )
+        return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
 
 
 def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:
@@ -321,9 +217,7 @@ def universal_root_validator(
 ) -> Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            # In Pydantic v2, for RootModel we always use "before" mode
-            # The custom validators transform the input value before the model is created
-            return cast(AnyCallable, pydantic.model_validator(mode="before")(func))  # type: ignore[attr-defined]
+            return cast(AnyCallable, pydantic.model_validator(mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
         return cast(AnyCallable, pydantic.root_validator(pre=pre)(func))  # type: ignore[call-overload]
 
     return decorator