Add files using upload-large-folder tool

venv/lib/python3.12/site-packages/anyio-4.13.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Alex Grönholm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

venv/lib/python3.12/site-packages/sarvamai/chat/__init__.py

@@ -0,0 +1,4 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+

venv/lib/python3.12/site-packages/sarvamai/chat/client.py

@@ -0,0 +1,446 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from ..requests.chat_completion_request_message import ChatCompletionRequestMessageParams
+from ..requests.chat_completion_tool import ChatCompletionToolParams
+from ..requests.stop_configuration import StopConfigurationParams
+from ..requests.tool_choice_option import ToolChoiceOptionParams
+from ..types.chat_completion_chunk import ChatCompletionChunk
+from ..types.create_chat_completion_response import CreateChatCompletionResponse
+from ..types.reasoning_effort import ReasoningEffort
+from ..types.sarvam_model_ids import SarvamModelIds
+from .raw_client import AsyncRawChatClient, RawChatClient
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class ChatClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawChatClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawChatClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawChatClient
+        """
+        return self._raw_client
+
+    @typing.overload
+    def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Literal[True],
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> typing.Iterator[ChatCompletionChunk]: ...
+
+    @typing.overload
+    def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Optional[typing.Literal[False]] = ...,
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> CreateChatCompletionResponse: ...
+
+    def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        reasoning_effort: typing.Optional[ReasoningEffort] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[StopConfigurationParams] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        seed: typing.Optional[int] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        wiki_grounding: typing.Optional[bool] = OMIT,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = OMIT,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Union[CreateChatCompletionResponse, typing.Iterator[ChatCompletionChunk]]:
+        """
+        Parameters
+        ----------
+        messages : typing.Sequence[ChatCompletionRequestMessageParams]
+            A list of messages comprising the conversation so far.
+
+        model : SarvamModelIds
+            Model ID used to generate the response, like `sarvam-m`.
+
+        temperature : typing.Optional[float]
+            What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+            We generally recommend altering this or `top_p` but not both.
+
+        top_p : typing.Optional[float]
+            An alternative to sampling with temperature, called nucleus sampling,
+            where the model considers the results of the tokens with top_p probability
+            mass. So 0.1 means only the tokens comprising the top 10% probability mass
+            are considered.
+
+            We generally recommend altering this or `temperature` but not both.
+
+        reasoning_effort : typing.Optional[ReasoningEffort]
+            The effort to use for reasoning
+
+        max_tokens : typing.Optional[int]
+            The maximum number of tokens that can be generated in the chat completion.
+
+        stream : typing.Optional[bool]
+            If set to true, the model response data will be streamed to the client
+            as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+            When true, returns an Iterator[ChatCompletionChunk] instead of CreateChatCompletionResponse.
+
+        stop : typing.Optional[StopConfigurationParams]
+
+        n : typing.Optional[int]
+            How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to minimize costs.
+
+        seed : typing.Optional[int]
+            This feature is in Beta.
+            If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same `seed` and parameters should return the same result.
+            Determinism is not guaranteed, and you should refer to the `system_fingerprint` response parameter to monitor changes in the backend.
+
+        frequency_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            their existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim.
+
+        presence_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            whether they appear in the text so far, increasing the model's likelihood
+            to talk about new topics.
+
+        wiki_grounding : typing.Optional[bool]
+            If set to true, the model response will be wiki grounded.
+
+        tools : typing.Optional[typing.Sequence[ChatCompletionToolParams]]
+            A list of tools the model may call. Currently, only functions are supported as a tool.
+
+        tool_choice : typing.Optional[ToolChoiceOptionParams]
+            Controls which (if any) tool is called by the model.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        CreateChatCompletionResponse or Iterator[ChatCompletionChunk]
+            When stream=False (default): CreateChatCompletionResponse.
+            When stream=True: Iterator yielding ChatCompletionChunk objects.
+
+        Examples
+        --------
+        from sarvamai import SarvamAI
+
+        client = SarvamAI(
+            api_subscription_key="YOUR_API_SUBSCRIPTION_KEY",
+        )
+
+        # Non-streaming
+        response = client.chat.completions(
+            messages=[{"role": "user", "content": "Hello"}],
+            model="sarvam-m",
+        )
+
+        # Streaming
+        for chunk in client.chat.completions(
+            messages=[{"role": "user", "content": "Hello"}],
+            model="sarvam-m",
+            stream=True,
+        ):
+            print(chunk)
+        """
+        if stream is True:
+            return self._raw_client.completions(
+                messages=messages,
+                model=model,
+                temperature=temperature,
+                top_p=top_p,
+                reasoning_effort=reasoning_effort,
+                max_tokens=max_tokens,
+                stream=True,
+                stop=stop,
+                n=n,
+                seed=seed,
+                frequency_penalty=frequency_penalty,
+                presence_penalty=presence_penalty,
+                wiki_grounding=wiki_grounding,
+                tools=tools,
+                tool_choice=tool_choice,
+                request_options=request_options,
+            )
+
+        _response = self._raw_client.completions(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            top_p=top_p,
+            reasoning_effort=reasoning_effort,
+            max_tokens=max_tokens,
+            stream=stream,
+            stop=stop,
+            n=n,
+            seed=seed,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            wiki_grounding=wiki_grounding,
+            tools=tools,
+            tool_choice=tool_choice,
+            request_options=request_options,
+        )
+        return _response.data
+
+
+class AsyncChatClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawChatClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawChatClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawChatClient
+        """
+        return self._raw_client
+
+    @typing.overload
+    async def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Literal[True],
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> typing.AsyncIterator[ChatCompletionChunk]: ...
+
+    @typing.overload
+    async def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Optional[typing.Literal[False]] = ...,
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> CreateChatCompletionResponse: ...
+
+    async def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        reasoning_effort: typing.Optional[ReasoningEffort] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[StopConfigurationParams] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        seed: typing.Optional[int] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        wiki_grounding: typing.Optional[bool] = OMIT,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = OMIT,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Union[CreateChatCompletionResponse, typing.AsyncIterator[ChatCompletionChunk]]:
+        """
+        Parameters
+        ----------
+        messages : typing.Sequence[ChatCompletionRequestMessageParams]
+            A list of messages comprising the conversation so far.
+
+        model : SarvamModelIds
+            Model ID used to generate the response, like `sarvam-m`.
+
+        temperature : typing.Optional[float]
+            What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+            We generally recommend altering this or `top_p` but not both.
+
+        top_p : typing.Optional[float]
+            An alternative to sampling with temperature, called nucleus sampling,
+            where the model considers the results of the tokens with top_p probability
+            mass. So 0.1 means only the tokens comprising the top 10% probability mass
+            are considered.
+
+            We generally recommend altering this or `temperature` but not both.
+
+        reasoning_effort : typing.Optional[ReasoningEffort]
+            The effort to use for reasoning
+
+        max_tokens : typing.Optional[int]
+            The maximum number of tokens that can be generated in the chat completion.
+
+        stream : typing.Optional[bool]
+            If set to true, the model response data will be streamed to the client
+            as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+            When true, returns an AsyncIterator[ChatCompletionChunk] instead of CreateChatCompletionResponse.
+
+        stop : typing.Optional[StopConfigurationParams]
+
+        n : typing.Optional[int]
+            How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to minimize costs.
+
+        seed : typing.Optional[int]
+            This feature is in Beta.
+            If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same `seed` and parameters should return the same result.
+            Determinism is not guaranteed, and you should refer to the `system_fingerprint` response parameter to monitor changes in the backend.
+
+        frequency_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            their existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim.
+
+        presence_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            whether they appear in the text so far, increasing the model's likelihood
+            to talk about new topics.
+
+        wiki_grounding : typing.Optional[bool]
+            If set to true, the model response will be wiki grounded.
+
+        tools : typing.Optional[typing.Sequence[ChatCompletionToolParams]]
+            A list of tools the model may call. Currently, only functions are supported as a tool.
+
+        tool_choice : typing.Optional[ToolChoiceOptionParams]
+            Controls which (if any) tool is called by the model.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        CreateChatCompletionResponse or AsyncIterator[ChatCompletionChunk]
+            When stream=False (default): CreateChatCompletionResponse.
+            When stream=True: AsyncIterator yielding ChatCompletionChunk objects.
+
+        Examples
+        --------
+        import asyncio
+        from sarvamai import AsyncSarvamAI
+
+        client = AsyncSarvamAI(
+            api_subscription_key="YOUR_API_SUBSCRIPTION_KEY",
+        )
+
+        async def main() -> None:
+            # Non-streaming
+            response = await client.chat.completions(
+                messages=[{"role": "user", "content": "Hello"}],
+                model="sarvam-m",
+            )
+
+            # Streaming
+            async for chunk in client.chat.completions(
+                messages=[{"role": "user", "content": "Hello"}],
+                model="sarvam-m",
+                stream=True,
+            ):
+                print(chunk)
+
+        asyncio.run(main())
+        """
+        if stream is True:
+            return await self._raw_client.completions(
+                messages=messages,
+                model=model,
+                temperature=temperature,
+                top_p=top_p,
+                reasoning_effort=reasoning_effort,
+                max_tokens=max_tokens,
+                stream=True,
+                stop=stop,
+                n=n,
+                seed=seed,
+                frequency_penalty=frequency_penalty,
+                presence_penalty=presence_penalty,
+                wiki_grounding=wiki_grounding,
+                tools=tools,
+                tool_choice=tool_choice,
+                request_options=request_options,
+            )
+
+        _response = await self._raw_client.completions(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            top_p=top_p,
+            reasoning_effort=reasoning_effort,
+            max_tokens=max_tokens,
+            stream=stream,
+            stop=stop,
+            n=n,
+            seed=seed,
+            frequency_penalty=frequency_penalty,
+            presence_penalty=presence_penalty,
+            wiki_grounding=wiki_grounding,
+            tools=tools,
+            tool_choice=tool_choice,
+            request_options=request_options,
+        )
+        return _response.data

venv/lib/python3.12/site-packages/sarvamai/chat/raw_client.py

@@ -0,0 +1,718 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import json
+import typing
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
+from ..core.pydantic_utilities import parse_obj_as
+from ..core.request_options import RequestOptions
+from ..core.serialization import convert_and_respect_annotation_metadata
+from ..errors.bad_request_error import BadRequestError
+from ..errors.forbidden_error import ForbiddenError
+from ..errors.internal_server_error import InternalServerError
+from ..errors.too_many_requests_error import TooManyRequestsError
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..requests.chat_completion_request_message import ChatCompletionRequestMessageParams
+from ..requests.chat_completion_tool import ChatCompletionToolParams
+from ..requests.stop_configuration import StopConfigurationParams
+from ..requests.tool_choice_option import ToolChoiceOptionParams
+from ..types.chat_completion_chunk import ChatCompletionChunk
+from ..types.create_chat_completion_response import CreateChatCompletionResponse
+from ..types.reasoning_effort import ReasoningEffort
+from ..types.sarvam_model_ids import SarvamModelIds
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawChatClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    @typing.overload
+    def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Literal[True],
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> typing.Iterator[ChatCompletionChunk]: ...
+
+    @typing.overload
+    def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Optional[typing.Literal[False]] = ...,
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> HttpResponse[CreateChatCompletionResponse]: ...
+
+    def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        reasoning_effort: typing.Optional[ReasoningEffort] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[StopConfigurationParams] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        seed: typing.Optional[int] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        wiki_grounding: typing.Optional[bool] = OMIT,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = OMIT,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Union[HttpResponse[CreateChatCompletionResponse], typing.Iterator[ChatCompletionChunk]]:
+        """
+        Parameters
+        ----------
+        messages : typing.Sequence[ChatCompletionRequestMessageParams]
+            A list of messages comprising the conversation so far.
+
+        model : SarvamModelIds
+            Model ID used to generate the response, like `sarvam-m`.
+
+        temperature : typing.Optional[float]
+            What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+            We generally recommend altering this or `top_p` but not both.
+
+        top_p : typing.Optional[float]
+            An alternative to sampling with temperature, called nucleus sampling,
+            where the model considers the results of the tokens with top_p probability
+            mass. So 0.1 means only the tokens comprising the top 10% probability mass
+            are considered.
+
+            We generally recommend altering this or `temperature` but not both.
+
+        reasoning_effort : typing.Optional[ReasoningEffort]
+            The effort to use for reasoning
+
+        max_tokens : typing.Optional[int]
+            The maximum number of tokens that can be generated in the chat completion.
+
+        stream : typing.Optional[bool]
+            If set to true, the model response data will be streamed to the client
+            as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+            When true, returns an Iterator[ChatCompletionChunk] instead of HttpResponse.
+
+        stop : typing.Optional[StopConfigurationParams]
+
+        n : typing.Optional[int]
+            How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to minimize costs.
+
+        seed : typing.Optional[int]
+            This feature is in Beta.
+            If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same `seed` and parameters should return the same result.
+            Determinism is not guaranteed, and you should refer to the `system_fingerprint` response parameter to monitor changes in the backend.
+
+        frequency_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            their existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim.
+
+        presence_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            whether they appear in the text so far, increasing the model's likelihood
+            to talk about new topics.
+
+        wiki_grounding : typing.Optional[bool]
+            If set to true, the model response will be wiki grounded.
+
+        tools : typing.Optional[typing.Sequence[ChatCompletionToolParams]]
+            A list of tools the model may call. Currently, only functions are supported as a tool.
+
+        tool_choice : typing.Optional[ToolChoiceOptionParams]
+            Controls which (if any) tool is called by the model.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[CreateChatCompletionResponse] or Iterator[ChatCompletionChunk]
+            When stream=False (default): HttpResponse wrapping CreateChatCompletionResponse.
+            When stream=True: Iterator yielding ChatCompletionChunk objects.
+        """
+        if stream is True:
+            return self._completions_stream(
+                messages=messages,
+                model=model,
+                temperature=temperature,
+                top_p=top_p,
+                reasoning_effort=reasoning_effort,
+                max_tokens=max_tokens,
+                stop=stop,
+                n=n,
+                seed=seed,
+                frequency_penalty=frequency_penalty,
+                presence_penalty=presence_penalty,
+                wiki_grounding=wiki_grounding,
+                tools=tools,
+                tool_choice=tool_choice,
+                request_options=request_options,
+            )
+
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/chat/completions",
+            base_url=self._client_wrapper.get_environment().base,
+            method="POST",
+            json={
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[ChatCompletionRequestMessageParams], direction="write"
+                ),
+                "model": model,
+                "temperature": temperature,
+                "top_p": top_p,
+                "reasoning_effort": reasoning_effort,
+                "max_tokens": max_tokens,
+                "stream": stream,
+                "stop": convert_and_respect_annotation_metadata(
+                    object_=stop, annotation=StopConfigurationParams, direction="write"
+                ),
+                "n": n,
+                "seed": seed,
+                "frequency_penalty": frequency_penalty,
+                "presence_penalty": presence_penalty,
+                "wiki_grounding": wiki_grounding,
+                "tools": convert_and_respect_annotation_metadata(
+                    object_=tools, annotation=typing.Sequence[ChatCompletionToolParams], direction="write"
+                ),
+                "tool_choice": convert_and_respect_annotation_metadata(
+                    object_=tool_choice, annotation=ToolChoiceOptionParams, direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CreateChatCompletionResponse,
+                    parse_obj_as(
+                        type_=CreateChatCompletionResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 429:
+                raise TooManyRequestsError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    def _completions_stream(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        reasoning_effort: typing.Optional[ReasoningEffort] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        stop: typing.Optional[StopConfigurationParams] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        seed: typing.Optional[int] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        wiki_grounding: typing.Optional[bool] = OMIT,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = OMIT,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Iterator[ChatCompletionChunk]:
+        with self._client_wrapper.httpx_client.stream(
+            "v1/chat/completions",
+            base_url=self._client_wrapper.get_environment().base,
+            method="POST",
+            json={
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[ChatCompletionRequestMessageParams], direction="write"
+                ),
+                "model": model,
+                "temperature": temperature,
+                "top_p": top_p,
+                "reasoning_effort": reasoning_effort,
+                "max_tokens": max_tokens,
+                "stream": True,
+                "stop": convert_and_respect_annotation_metadata(
+                    object_=stop, annotation=StopConfigurationParams, direction="write"
+                ),
+                "n": n,
+                "seed": seed,
+                "frequency_penalty": frequency_penalty,
+                "presence_penalty": presence_penalty,
+                "wiki_grounding": wiki_grounding,
+                "tools": convert_and_respect_annotation_metadata(
+                    object_=tools, annotation=typing.Sequence[ChatCompletionToolParams], direction="write"
+                ),
+                "tool_choice": convert_and_respect_annotation_metadata(
+                    object_=tool_choice, annotation=ToolChoiceOptionParams, direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        ) as _response:
+            if not (200 <= _response.status_code < 300):
+                _response.read()
+                try:
+                    _body = _response.json()
+                except Exception:
+                    _body = _response.text
+                raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_body)
+
+            for _line in _response.iter_lines():
+                if not _line:
+                    continue
+                if _line.startswith("data: "):
+                    _data_str = _line[len("data: "):]
+                    if _data_str.strip() == "[DONE]":
+                        return
+                    try:
+                        _chunk_json = json.loads(_data_str)
+                        _chunk = typing.cast(
+                            ChatCompletionChunk,
+                            parse_obj_as(
+                                type_=ChatCompletionChunk,  # type: ignore
+                                object_=_chunk_json,
+                            ),
+                        )
+                        yield _chunk
+                    except json.JSONDecodeError:
+                        continue
+
+
+class AsyncRawChatClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    @typing.overload
+    async def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Literal[True],
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> typing.AsyncIterator[ChatCompletionChunk]: ...
+
+    @typing.overload
+    async def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = ...,
+        top_p: typing.Optional[float] = ...,
+        reasoning_effort: typing.Optional[ReasoningEffort] = ...,
+        max_tokens: typing.Optional[int] = ...,
+        stream: typing.Optional[typing.Literal[False]] = ...,
+        stop: typing.Optional[StopConfigurationParams] = ...,
+        n: typing.Optional[int] = ...,
+        seed: typing.Optional[int] = ...,
+        frequency_penalty: typing.Optional[float] = ...,
+        presence_penalty: typing.Optional[float] = ...,
+        wiki_grounding: typing.Optional[bool] = ...,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = ...,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = ...,
+        request_options: typing.Optional[RequestOptions] = ...,
+    ) -> AsyncHttpResponse[CreateChatCompletionResponse]: ...
+
+    async def completions(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        reasoning_effort: typing.Optional[ReasoningEffort] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        stream: typing.Optional[bool] = OMIT,
+        stop: typing.Optional[StopConfigurationParams] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        seed: typing.Optional[int] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        wiki_grounding: typing.Optional[bool] = OMIT,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = OMIT,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Union[AsyncHttpResponse[CreateChatCompletionResponse], typing.AsyncIterator[ChatCompletionChunk]]:
+        """
+        Parameters
+        ----------
+        messages : typing.Sequence[ChatCompletionRequestMessageParams]
+            A list of messages comprising the conversation so far.
+
+        model : SarvamModelIds
+            Model ID used to generate the response, like `sarvam-m`.
+
+        temperature : typing.Optional[float]
+            What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+            We generally recommend altering this or `top_p` but not both.
+
+        top_p : typing.Optional[float]
+            An alternative to sampling with temperature, called nucleus sampling,
+            where the model considers the results of the tokens with top_p probability
+            mass. So 0.1 means only the tokens comprising the top 10% probability mass
+            are considered.
+
+            We generally recommend altering this or `temperature` but not both.
+
+        reasoning_effort : typing.Optional[ReasoningEffort]
+            The effort to use for reasoning
+
+        max_tokens : typing.Optional[int]
+            The maximum number of tokens that can be generated in the chat completion.
+
+        stream : typing.Optional[bool]
+            If set to true, the model response data will be streamed to the client
+            as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
+            When true, returns an AsyncIterator[ChatCompletionChunk] instead of AsyncHttpResponse.
+
+        stop : typing.Optional[StopConfigurationParams]
+
+        n : typing.Optional[int]
+            How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep `n` as `1` to minimize costs.
+
+        seed : typing.Optional[int]
+            This feature is in Beta.
+            If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same `seed` and parameters should return the same result.
+            Determinism is not guaranteed, and you should refer to the `system_fingerprint` response parameter to monitor changes in the backend.
+
+        frequency_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            their existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim.
+
+        presence_penalty : typing.Optional[float]
+            Number between -2.0 and 2.0. Positive values penalize new tokens based on
+            whether they appear in the text so far, increasing the model's likelihood
+            to talk about new topics.
+
+        wiki_grounding : typing.Optional[bool]
+            If set to true, the model response will be wiki grounded.
+
+        tools : typing.Optional[typing.Sequence[ChatCompletionToolParams]]
+            A list of tools the model may call. Currently, only functions are supported as a tool.
+
+        tool_choice : typing.Optional[ToolChoiceOptionParams]
+            Controls which (if any) tool is called by the model.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[CreateChatCompletionResponse] or AsyncIterator[ChatCompletionChunk]
+            When stream=False (default): AsyncHttpResponse wrapping CreateChatCompletionResponse.
+            When stream=True: AsyncIterator yielding ChatCompletionChunk objects.
+        """
+        if stream is True:
+            return self._completions_stream(
+                messages=messages,
+                model=model,
+                temperature=temperature,
+                top_p=top_p,
+                reasoning_effort=reasoning_effort,
+                max_tokens=max_tokens,
+                stop=stop,
+                n=n,
+                seed=seed,
+                frequency_penalty=frequency_penalty,
+                presence_penalty=presence_penalty,
+                wiki_grounding=wiki_grounding,
+                tools=tools,
+                tool_choice=tool_choice,
+                request_options=request_options,
+            )
+
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/chat/completions",
+            base_url=self._client_wrapper.get_environment().base,
+            method="POST",
+            json={
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[ChatCompletionRequestMessageParams], direction="write"
+                ),
+                "model": model,
+                "temperature": temperature,
+                "top_p": top_p,
+                "reasoning_effort": reasoning_effort,
+                "max_tokens": max_tokens,
+                "stream": stream,
+                "stop": convert_and_respect_annotation_metadata(
+                    object_=stop, annotation=StopConfigurationParams, direction="write"
+                ),
+                "n": n,
+                "seed": seed,
+                "frequency_penalty": frequency_penalty,
+                "presence_penalty": presence_penalty,
+                "wiki_grounding": wiki_grounding,
+                "tools": convert_and_respect_annotation_metadata(
+                    object_=tools, annotation=typing.Sequence[ChatCompletionToolParams], direction="write"
+                ),
+                "tool_choice": convert_and_respect_annotation_metadata(
+                    object_=tool_choice, annotation=ToolChoiceOptionParams, direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CreateChatCompletionResponse,
+                    parse_obj_as(
+                        type_=CreateChatCompletionResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 403:
+                raise ForbiddenError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 429:
+                raise TooManyRequestsError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Optional[typing.Any],
+                        parse_obj_as(
+                            type_=typing.Optional[typing.Any],  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def _completions_stream(
+        self,
+        *,
+        messages: typing.Sequence[ChatCompletionRequestMessageParams],
+        model: SarvamModelIds,
+        temperature: typing.Optional[float] = OMIT,
+        top_p: typing.Optional[float] = OMIT,
+        reasoning_effort: typing.Optional[ReasoningEffort] = OMIT,
+        max_tokens: typing.Optional[int] = OMIT,
+        stop: typing.Optional[StopConfigurationParams] = OMIT,
+        n: typing.Optional[int] = OMIT,
+        seed: typing.Optional[int] = OMIT,
+        frequency_penalty: typing.Optional[float] = OMIT,
+        presence_penalty: typing.Optional[float] = OMIT,
+        wiki_grounding: typing.Optional[bool] = OMIT,
+        tools: typing.Optional[typing.Sequence[ChatCompletionToolParams]] = OMIT,
+        tool_choice: typing.Optional[ToolChoiceOptionParams] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.AsyncIterator[ChatCompletionChunk]:
+        async with self._client_wrapper.httpx_client.stream(
+            "v1/chat/completions",
+            base_url=self._client_wrapper.get_environment().base,
+            method="POST",
+            json={
+                "messages": convert_and_respect_annotation_metadata(
+                    object_=messages, annotation=typing.Sequence[ChatCompletionRequestMessageParams], direction="write"
+                ),
+                "model": model,
+                "temperature": temperature,
+                "top_p": top_p,
+                "reasoning_effort": reasoning_effort,
+                "max_tokens": max_tokens,
+                "stream": True,
+                "stop": convert_and_respect_annotation_metadata(
+                    object_=stop, annotation=StopConfigurationParams, direction="write"
+                ),
+                "n": n,
+                "seed": seed,
+                "frequency_penalty": frequency_penalty,
+                "presence_penalty": presence_penalty,
+                "wiki_grounding": wiki_grounding,
+                "tools": convert_and_respect_annotation_metadata(
+                    object_=tools, annotation=typing.Sequence[ChatCompletionToolParams], direction="write"
+                ),
+                "tool_choice": convert_and_respect_annotation_metadata(
+                    object_=tool_choice, annotation=ToolChoiceOptionParams, direction="write"
+                ),
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        ) as _response:
+            if not (200 <= _response.status_code < 300):
+                await _response.aread()
+                try:
+                    _body = _response.json()
+                except Exception:
+                    _body = _response.text
+                raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_body)
+
+            async for _line in _response.aiter_lines():
+                if not _line:
+                    continue
+                if _line.startswith("data: "):
+                    _data_str = _line[len("data: "):]
+                    if _data_str.strip() == "[DONE]":
+                        return
+                    try:
+                        _chunk_json = json.loads(_data_str)
+                        _chunk = typing.cast(
+                            ChatCompletionChunk,
+                            parse_obj_as(
+                                type_=ChatCompletionChunk,  # type: ignore
+                                object_=_chunk_json,
+                            ),
+                        )
+                        yield _chunk
+                    except json.JSONDecodeError:
+                        continue

venv/lib/python3.12/site-packages/sarvamai/core/__init__.py

@@ -0,0 +1,132 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .api_error import ApiError
+    from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
+    from .datetime_utils import Rfc2822DateTime, parse_rfc2822_datetime, serialize_datetime
+    from .events import EventEmitterMixin, EventType
+    from .file import File, convert_file_dict_to_httpx_tuples, with_content_type
+    from .http_client import AsyncHttpClient, HttpClient
+    from .http_response import AsyncHttpResponse, HttpResponse
+    from .jsonable_encoder import jsonable_encoder
+    from .logging import ConsoleLogger, ILogger, LogConfig, LogLevel, Logger, create_logger
+    from .pydantic_utilities import (
+        IS_PYDANTIC_V2,
+        UniversalBaseModel,
+        UniversalRootModel,
+        parse_obj_as,
+        universal_field_validator,
+        universal_root_validator,
+        update_forward_refs,
+    )
+    from .query_encoder import encode_query
+    from .remove_none_from_dict import remove_none_from_dict
+    from .request_options import RequestOptions
+    from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+    from .websocket_compat import InvalidWebSocketStatus, get_status_code
+_dynamic_imports: typing.Dict[str, str] = {
+    "ApiError": ".api_error",
+    "AsyncClientWrapper": ".client_wrapper",
+    "AsyncHttpClient": ".http_client",
+    "AsyncHttpResponse": ".http_response",
+    "BaseClientWrapper": ".client_wrapper",
+    "ConsoleLogger": ".logging",
+    "EventEmitterMixin": ".events",
+    "EventType": ".events",
+    "FieldMetadata": ".serialization",
+    "File": ".file",
+    "HttpClient": ".http_client",
+    "HttpResponse": ".http_response",
+    "ILogger": ".logging",
+    "IS_PYDANTIC_V2": ".pydantic_utilities",
+    "InvalidWebSocketStatus": ".websocket_compat",
+    "LogConfig": ".logging",
+    "LogLevel": ".logging",
+    "Logger": ".logging",
+    "RequestOptions": ".request_options",
+    "Rfc2822DateTime": ".datetime_utils",
+    "SyncClientWrapper": ".client_wrapper",
+    "UniversalBaseModel": ".pydantic_utilities",
+    "UniversalRootModel": ".pydantic_utilities",
+    "convert_and_respect_annotation_metadata": ".serialization",
+    "convert_file_dict_to_httpx_tuples": ".file",
+    "create_logger": ".logging",
+    "encode_query": ".query_encoder",
+    "get_status_code": ".websocket_compat",
+    "jsonable_encoder": ".jsonable_encoder",
+    "parse_obj_as": ".pydantic_utilities",
+    "parse_rfc2822_datetime": ".datetime_utils",
+    "remove_none_from_dict": ".remove_none_from_dict",
+    "serialize_datetime": ".datetime_utils",
+    "universal_field_validator": ".pydantic_utilities",
+    "universal_root_validator": ".pydantic_utilities",
+    "update_forward_refs": ".pydantic_utilities",
+    "with_content_type": ".file",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = [
+    "ApiError",
+    "AsyncClientWrapper",
+    "AsyncHttpClient",
+    "AsyncHttpResponse",
+    "BaseClientWrapper",
+    "ConsoleLogger",
+    "EventEmitterMixin",
+    "EventType",
+    "FieldMetadata",
+    "File",
+    "HttpClient",
+    "HttpResponse",
+    "ILogger",
+    "IS_PYDANTIC_V2",
+    "InvalidWebSocketStatus",
+    "LogConfig",
+    "LogLevel",
+    "Logger",
+    "RequestOptions",
+    "Rfc2822DateTime",
+    "SyncClientWrapper",
+    "UniversalBaseModel",
+    "UniversalRootModel",
+    "convert_and_respect_annotation_metadata",
+    "convert_file_dict_to_httpx_tuples",
+    "create_logger",
+    "encode_query",
+    "get_status_code",
+    "jsonable_encoder",
+    "parse_obj_as",
+    "parse_rfc2822_datetime",
+    "remove_none_from_dict",
+    "serialize_datetime",
+    "universal_field_validator",
+    "universal_root_validator",
+    "update_forward_refs",
+    "with_content_type",
+]

venv/lib/python3.12/site-packages/sarvamai/core/api_error.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, Optional
+
+
+class ApiError(Exception):
+    headers: Optional[Dict[str, str]]
+    status_code: Optional[int]
+    body: Any
+
+    def __init__(
+        self,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        status_code: Optional[int] = None,
+        body: Any = None,
+    ) -> None:
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"headers: {self.headers}, status_code: {self.status_code}, body: {self.body}"

venv/lib/python3.12/site-packages/sarvamai/core/client_wrapper.py

@@ -0,0 +1,111 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+from ..environment import SarvamAIEnvironment
+from .http_client import AsyncHttpClient, HttpClient
+from .logging import LogConfig, Logger
+
+
+class BaseClientWrapper:
+    def __init__(
+        self,
+        *,
+        api_subscription_key: str,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        environment: SarvamAIEnvironment,
+        timeout: typing.Optional[float] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+    ):
+        self.api_subscription_key = api_subscription_key
+        self._headers = headers
+        self._environment = environment
+        self._timeout = timeout
+        self._logging = logging
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        import platform
+
+        headers: typing.Dict[str, str] = {
+            "User-Agent": "sarvamai/0.1.28",
+            "X-Fern-Language": "Python",
+            "X-Fern-Runtime": f"python/{platform.python_version()}",
+            "X-Fern-Platform": f"{platform.system().lower()}/{platform.release()}",
+            "X-Fern-SDK-Name": "sarvamai",
+            "X-Fern-SDK-Version": "0.1.28",
+            **(self.get_custom_headers() or {}),
+        }
+        headers["api-subscription-key"] = self.api_subscription_key
+        return headers
+
+    def get_custom_headers(self) -> typing.Optional[typing.Dict[str, str]]:
+        return self._headers
+
+    def get_environment(self) -> SarvamAIEnvironment:
+        return self._environment
+
+    def get_timeout(self) -> typing.Optional[float]:
+        return self._timeout
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        api_subscription_key: str,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        environment: SarvamAIEnvironment,
+        timeout: typing.Optional[float] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+        httpx_client: httpx.Client,
+    ):
+        super().__init__(
+            api_subscription_key=api_subscription_key,
+            headers=headers,
+            environment=environment,
+            timeout=timeout,
+            logging=logging,
+        )
+        self.httpx_client = HttpClient(
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            logging_config=self._logging,
+        )
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        api_subscription_key: str,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        environment: SarvamAIEnvironment,
+        timeout: typing.Optional[float] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+        async_token: typing.Optional[typing.Callable[[], typing.Awaitable[str]]] = None,
+        httpx_client: httpx.AsyncClient,
+    ):
+        super().__init__(
+            api_subscription_key=api_subscription_key,
+            headers=headers,
+            environment=environment,
+            timeout=timeout,
+            logging=logging,
+        )
+        self._async_token = async_token
+        self.httpx_client = AsyncHttpClient(
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            async_base_headers=self.async_get_headers,
+            logging_config=self._logging,
+        )
+
+    async def async_get_headers(self) -> typing.Dict[str, str]:
+        headers = self.get_headers()
+        if self._async_token is not None:
+            token = await self._async_token()
+            headers["Authorization"] = f"Bearer {token}"
+        return headers

venv/lib/python3.12/site-packages/sarvamai/core/datetime_utils.py

@@ -0,0 +1,70 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+from email.utils import parsedate_to_datetime
+from typing import Any
+
+import pydantic
+
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+
+def parse_rfc2822_datetime(v: Any) -> dt.datetime:
+    """
+    Parse an RFC 2822 datetime string (e.g., "Wed, 02 Oct 2002 13:00:00 GMT")
+    into a datetime object. If the value is already a datetime, return it as-is.
+    Falls back to ISO 8601 parsing if RFC 2822 parsing fails.
+    """
+    if isinstance(v, dt.datetime):
+        return v
+    if isinstance(v, str):
+        try:
+            return parsedate_to_datetime(v)
+        except Exception:
+            pass
+        # Fallback to ISO 8601 parsing
+        return dt.datetime.fromisoformat(v.replace("Z", "+00:00"))
+    raise ValueError(f"Expected str or datetime, got {type(v)}")
+
+
+class Rfc2822DateTime(dt.datetime):
+    """A datetime subclass that parses RFC 2822 date strings.
+
+    On Pydantic V1, uses __get_validators__ for pre-validation.
+    On Pydantic V2, uses __get_pydantic_core_schema__ for BeforeValidator-style parsing.
+    """
+
+    @classmethod
+    def __get_validators__(cls):  # type: ignore[no-untyped-def]
+        yield parse_rfc2822_datetime
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> Any:  # type: ignore[override]
+        from pydantic_core import core_schema
+
+        return core_schema.no_info_before_validator_function(parse_rfc2822_datetime, core_schema.datetime_schema())
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(None):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

venv/lib/python3.12/site-packages/sarvamai/core/events.py

@@ -0,0 +1,38 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import inspect
+import typing
+from enum import Enum
+
+
+class EventType(str, Enum):
+    OPEN = "open"
+    MESSAGE = "message"
+    ERROR = "error"
+    CLOSE = "close"
+
+
+class EventEmitterMixin:
+    """
+    Simple mixin for registering and emitting events.
+    """
+
+    def __init__(self) -> None:
+        self._callbacks: typing.Dict[EventType, typing.List[typing.Callable]] = {}
+
+    def on(self, event_name: EventType, callback: typing.Callable[[typing.Any], typing.Any]) -> None:
+        if event_name not in self._callbacks:
+            self._callbacks[event_name] = []
+        self._callbacks[event_name].append(callback)
+
+    def _emit(self, event_name: EventType, data: typing.Any) -> None:
+        if event_name in self._callbacks:
+            for cb in self._callbacks[event_name]:
+                cb(data)
+
+    async def _emit_async(self, event_name: EventType, data: typing.Any) -> None:
+        if event_name in self._callbacks:
+            for cb in self._callbacks[event_name]:
+                res = cb(data)
+                if inspect.isawaitable(res):
+                    await res

venv/lib/python3.12/site-packages/sarvamai/core/file.py

@@ -0,0 +1,67 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import IO, Dict, List, Mapping, Optional, Tuple, Union, cast
+
+# File typing inspired by the flexibility of types within the httpx library
+# https://github.com/encode/httpx/blob/master/httpx/_types.py
+FileContent = Union[IO[bytes], bytes, str]
+File = Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    Tuple[Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    Tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    Tuple[
+        Optional[str],
+        FileContent,
+        Optional[str],
+        Mapping[str, str],
+    ],
+]
+
+
+def convert_file_dict_to_httpx_tuples(
+    d: Dict[str, Union[File, List[File]]],
+) -> List[Tuple[str, File]]:
+    """
+    The format we use is a list of tuples, where the first element is the
+    name of the file and the second is the file object. Typically HTTPX wants
+    a dict, but to be able to send lists of files, you have to use the list
+    approach (which also works for non-lists)
+    https://github.com/encode/httpx/pull/1032
+    """
+
+    httpx_tuples = []
+    for key, file_like in d.items():
+        if isinstance(file_like, list):
+            for file_like_item in file_like:
+                httpx_tuples.append((key, file_like_item))
+        else:
+            httpx_tuples.append((key, file_like))
+    return httpx_tuples
+
+
+def with_content_type(*, file: File, default_content_type: str) -> File:
+    """
+    This function resolves to the file's content type, if provided, and defaults
+    to the default_content_type value if not.
+    """
+    if isinstance(file, tuple):
+        if len(file) == 2:
+            filename, content = cast(Tuple[Optional[str], FileContent], file)  # type: ignore
+            return (filename, content, default_content_type)
+        elif len(file) == 3:
+            filename, content, file_content_type = cast(Tuple[Optional[str], FileContent, Optional[str]], file)  # type: ignore
+            out_content_type = file_content_type or default_content_type
+            return (filename, content, out_content_type)
+        elif len(file) == 4:
+            filename, content, file_content_type, headers = cast(  # type: ignore
+                Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]], file
+            )
+            out_content_type = file_content_type or default_content_type
+            return (filename, content, out_content_type, headers)
+        else:
+            raise ValueError(f"Unexpected tuple length: {len(file)}")
+    return (None, file, default_content_type)

venv/lib/python3.12/site-packages/sarvamai/core/force_multipart.py

@@ -0,0 +1,18 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict
+
+
+class ForceMultipartDict(Dict[str, Any]):
+    """
+    A dictionary subclass that always evaluates to True in boolean contexts.
+
+    This is used to force multipart/form-data encoding in HTTP requests even when
+    the dictionary is empty, which would normally evaluate to False.
+    """
+
+    def __bool__(self) -> bool:
+        return True
+
+
+FORCE_MULTIPART = ForceMultipartDict()

venv/lib/python3.12/site-packages/sarvamai/core/http_client.py

@@ -0,0 +1,776 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import asyncio
+import email.utils
+import re
+import time
+import typing
+from contextlib import asynccontextmanager, contextmanager
+from random import random
+
+import httpx
+from .file import File, convert_file_dict_to_httpx_tuples
+from .force_multipart import FORCE_MULTIPART
+from .jsonable_encoder import jsonable_encoder
+from .logging import LogConfig, Logger, create_logger
+from .query_encoder import encode_query
+from .remove_none_from_dict import remove_none_from_dict as 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
+
+
+def _parse_retry_after(response_headers: httpx.Headers) -> typing.Optional[float]:
+    """
+    This function parses the `Retry-After` header in a HTTP response and returns the number of seconds to wait.
+
+    Inspired by the urllib3 retry implementation.
+    """
+    retry_after_ms = response_headers.get("retry-after-ms")
+    if retry_after_ms is not None:
+        try:
+            return int(retry_after_ms) / 1000 if retry_after_ms > 0 else 0
+        except Exception:
+            pass
+
+    retry_after = response_headers.get("retry-after")
+    if retry_after is None:
+        return None
+
+    # Attempt to parse the header as an int.
+    if re.match(r"^\s*[0-9]+\s*$", retry_after):
+        seconds = float(retry_after)
+    # Fallback to parsing it as a date.
+    else:
+        retry_date_tuple = email.utils.parsedate_tz(retry_after)
+        if retry_date_tuple is None:
+            return None
+        if retry_date_tuple[9] is None:  # Python 2
+            # Assume UTC if no timezone was specified
+            # On Python2.7, parsedate_tz returns None for a timezone offset
+            # instead of 0 if no timezone is given, where mktime_tz treats
+            # a None timezone offset as local time.
+            retry_date_tuple = retry_date_tuple[:9] + (0,) + retry_date_tuple[10:]
+
+        retry_date = email.utils.mktime_tz(retry_date_tuple)
+        seconds = retry_date - time.time()
+
+    if seconds < 0:
+        seconds = 0
+
+    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.
+    This function begins by trying to parse a retry-after header from the response, and then proceeds to use exponential backoff
+    with a jitter to determine the number of seconds to wait.
+    """
+
+    # 1. Check Retry-After header first
+    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)
+
+    # 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))
+
+    # 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)
+
+
+def _should_retry(response: httpx.Response) -> bool:
+    retryable_400s = [429, 408, 409]
+    return response.status_code >= 500 or response.status_code in retryable_400s
+
+
+_SENSITIVE_HEADERS = frozenset(
+    {
+        "authorization",
+        "www-authenticate",
+        "x-api-key",
+        "api-key",
+        "apikey",
+        "x-api-token",
+        "x-auth-token",
+        "auth-token",
+        "cookie",
+        "set-cookie",
+        "proxy-authorization",
+        "proxy-authenticate",
+        "x-csrf-token",
+        "x-xsrf-token",
+        "x-session-token",
+        "x-access-token",
+    }
+)
+
+
+def _redact_headers(headers: typing.Dict[str, str]) -> typing.Dict[str, str]:
+    return {k: ("[REDACTED]" if k.lower() in _SENSITIVE_HEADERS else v) for k, v in headers.items()}
+
+
+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],
+) -> typing.Dict[str, typing.Any]:
+    if omit is None:
+        return original
+    new: typing.Dict[str, typing.Any] = {}
+    for key, value in original.items():
+        if value is not omit:
+            new[key] = value
+    return new
+
+
+def maybe_filter_request_body(
+    data: typing.Optional[typing.Any],
+    request_options: typing.Optional[RequestOptions],
+    omit: typing.Optional[typing.Any],
+) -> typing.Optional[typing.Any]:
+    if data is None:
+        return (
+            jsonable_encoder(request_options.get("additional_body_parameters", {})) or {}
+            if request_options is not None
+            else None
+        )
+    elif not isinstance(data, typing.Mapping):
+        data_content = jsonable_encoder(data)
+    else:
+        data_content = {
+            **(jsonable_encoder(remove_omit_from_dict(data, omit))),  # type: ignore
+            **(
+                jsonable_encoder(request_options.get("additional_body_parameters", {})) or {}
+                if request_options is not None
+                else {}
+            ),
+        }
+    return data_content
+
+
+# Abstracted out for testing purposes
+def get_request_body(
+    *,
+    json: typing.Optional[typing.Any],
+    data: typing.Optional[typing.Any],
+    request_options: typing.Optional[RequestOptions],
+    omit: typing.Optional[typing.Any],
+) -> typing.Tuple[typing.Optional[typing.Any], typing.Optional[typing.Any]]:
+    json_body = None
+    data_body = None
+    if data is not None:
+        data_body = maybe_filter_request_body(data, request_options, omit)
+    else:
+        # 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
+
+
+class HttpClient:
+    def __init__(
+        self,
+        *,
+        httpx_client: httpx.Client,
+        base_timeout: typing.Callable[[], typing.Optional[float]],
+        base_headers: typing.Callable[[], typing.Dict[str, str]],
+        base_url: typing.Optional[typing.Callable[[], str]] = None,
+        logging_config: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+    ):
+        self.base_url = base_url
+        self.base_timeout = base_timeout
+        self.base_headers = base_headers
+        self.httpx_client = httpx_client
+        self.logger = create_logger(logging_config)
+
+    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:
+            base_url = self.base_url()
+
+        if base_url is None:
+            raise ValueError("A base_url is required to make this request, please provide one and try again.")
+        return base_url
+
+    def request(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
+                typing.List[typing.Tuple[str, File]],
+            ]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+        force_multipart: typing.Optional[bool] = None,
+    ) -> httpx.Response:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout()
+        )
+
+        json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
+
+        request_files: typing.Optional[RequestFiles] = (
+            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+            if (files is not None and files is not omit and isinstance(files, dict))
+            else None
+        )
+
+        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,
+                    )
+                )
+            )
+        )
+
+        _request_url = _build_url(base_url, path)
+        _request_headers = jsonable_encoder(
+            remove_none_from_dict(
+                {
+                    **self.base_headers(),
+                    **(headers if headers is not None else {}),
+                    **(request_options.get("additional_headers", {}) or {} if request_options is not None else {}),
+                }
+            )
+        )
+
+        if self.logger.is_debug():
+            self.logger.debug(
+                "Making HTTP request",
+                method=method,
+                url=_request_url,
+                headers=_redact_headers(_request_headers),
+                has_body=json_body is not None or data_body is not None,
+            )
+
+        response = self.httpx_client.request(
+            method=method,
+            url=_request_url,
+            headers=_request_headers,
+            params=_encoded_params if _encoded_params else None,
+            json=json_body,
+            data=data_body,
+            content=content,
+            files=request_files,
+            timeout=timeout,
+        )
+
+        max_retries: int = request_options.get("max_retries", 2) if request_options is not None else 2
+        if _should_retry(response=response):
+            if retries < max_retries:
+                time.sleep(_retry_timeout(response=response, retries=retries))
+                return self.request(
+                    path=path,
+                    method=method,
+                    base_url=base_url,
+                    params=params,
+                    json=json,
+                    content=content,
+                    files=files,
+                    headers=headers,
+                    request_options=request_options,
+                    retries=retries + 1,
+                    omit=omit,
+                )
+
+        if self.logger.is_debug():
+            if 200 <= response.status_code < 400:
+                self.logger.debug(
+                    "HTTP request succeeded",
+                    method=method,
+                    url=_request_url,
+                    status_code=response.status_code,
+                )
+
+        if self.logger.is_error():
+            if response.status_code >= 400:
+                self.logger.error(
+                    "HTTP request failed with error status",
+                    method=method,
+                    url=_request_url,
+                    status_code=response.status_code,
+                )
+
+        return response
+
+    @contextmanager
+    def stream(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
+                typing.List[typing.Tuple[str, File]],
+            ]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+        force_multipart: typing.Optional[bool] = None,
+    ) -> typing.Iterator[httpx.Response]:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout()
+        )
+
+        request_files: typing.Optional[RequestFiles] = (
+            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+            if (files is not None and files is not omit and isinstance(files, dict))
+            else None
+        )
+
+        if (request_files is None or len(request_files) == 0) and force_multipart:
+            request_files = FORCE_MULTIPART
+
+        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,
+                    )
+                )
+            )
+        )
+
+        _request_url = _build_url(base_url, path)
+        _request_headers = jsonable_encoder(
+            remove_none_from_dict(
+                {
+                    **self.base_headers(),
+                    **(headers if headers is not None else {}),
+                    **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                }
+            )
+        )
+
+        if self.logger.is_debug():
+            self.logger.debug(
+                "Making streaming HTTP request",
+                method=method,
+                url=_request_url,
+                headers=_redact_headers(_request_headers),
+            )
+
+        with self.httpx_client.stream(
+            method=method,
+            url=_request_url,
+            headers=_request_headers,
+            params=_encoded_params if _encoded_params else None,
+            json=json_body,
+            data=data_body,
+            content=content,
+            files=request_files,
+            timeout=timeout,
+        ) as stream:
+            yield stream
+
+
+class AsyncHttpClient:
+    def __init__(
+        self,
+        *,
+        httpx_client: httpx.AsyncClient,
+        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,
+        logging_config: typing.Optional[typing.Union[LogConfig, Logger]] = 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
+        self.logger = create_logger(logging_config)
+
+    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:
+            base_url = self.base_url()
+
+        if base_url is None:
+            raise ValueError("A base_url is required to make this request, please provide one and try again.")
+        return base_url
+
+    async def request(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
+                typing.List[typing.Tuple[str, File]],
+            ]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+        force_multipart: typing.Optional[bool] = None,
+    ) -> httpx.Response:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout()
+        )
+
+        request_files: typing.Optional[RequestFiles] = (
+            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+            if (files is not None and files is not omit and isinstance(files, dict))
+            else None
+        )
+
+        if (request_files is None or len(request_files) == 0) and force_multipart:
+            request_files = FORCE_MULTIPART
+
+        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,
+                    )
+                )
+            )
+        )
+
+        _request_url = _build_url(base_url, path)
+        _request_headers = jsonable_encoder(
+            remove_none_from_dict(
+                {
+                    **_headers,
+                    **(headers if headers is not None else {}),
+                    **(request_options.get("additional_headers", {}) or {} if request_options is not None else {}),
+                }
+            )
+        )
+
+        if self.logger.is_debug():
+            self.logger.debug(
+                "Making HTTP request",
+                method=method,
+                url=_request_url,
+                headers=_redact_headers(_request_headers),
+                has_body=json_body is not None or data_body is not None,
+            )
+
+        response = await self.httpx_client.request(
+            method=method,
+            url=_request_url,
+            headers=_request_headers,
+            params=_encoded_params if _encoded_params else None,
+            json=json_body,
+            data=data_body,
+            content=content,
+            files=request_files,
+            timeout=timeout,
+        )
+
+        max_retries: int = request_options.get("max_retries", 2) if request_options is not None else 2
+        if _should_retry(response=response):
+            if retries < max_retries:
+                await asyncio.sleep(_retry_timeout(response=response, retries=retries))
+                return await self.request(
+                    path=path,
+                    method=method,
+                    base_url=base_url,
+                    params=params,
+                    json=json,
+                    content=content,
+                    files=files,
+                    headers=headers,
+                    request_options=request_options,
+                    retries=retries + 1,
+                    omit=omit,
+                )
+
+        if self.logger.is_debug():
+            if 200 <= response.status_code < 400:
+                self.logger.debug(
+                    "HTTP request succeeded",
+                    method=method,
+                    url=_request_url,
+                    status_code=response.status_code,
+                )
+
+        if self.logger.is_error():
+            if response.status_code >= 400:
+                self.logger.error(
+                    "HTTP request failed with error status",
+                    method=method,
+                    url=_request_url,
+                    status_code=response.status_code,
+                )
+
+        return response
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        path: typing.Optional[str] = None,
+        *,
+        method: str,
+        base_url: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        json: typing.Optional[typing.Any] = None,
+        data: typing.Optional[typing.Any] = None,
+        content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
+        files: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
+                typing.List[typing.Tuple[str, File]],
+            ]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+        retries: int = 0,
+        omit: typing.Optional[typing.Any] = None,
+        force_multipart: typing.Optional[bool] = None,
+    ) -> typing.AsyncIterator[httpx.Response]:
+        base_url = self.get_base_url(base_url)
+        timeout = (
+            request_options.get("timeout_in_seconds")
+            if request_options is not None and request_options.get("timeout_in_seconds") is not None
+            else self.base_timeout()
+        )
+
+        request_files: typing.Optional[RequestFiles] = (
+            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+            if (files is not None and files is not omit and isinstance(files, dict))
+            else None
+        )
+
+        if (request_files is None or len(request_files) == 0) and force_multipart:
+            request_files = FORCE_MULTIPART
+
+        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,
+                    )
+                )
+            )
+        )
+
+        _request_url = _build_url(base_url, path)
+        _request_headers = jsonable_encoder(
+            remove_none_from_dict(
+                {
+                    **_headers,
+                    **(headers if headers is not None else {}),
+                    **(request_options.get("additional_headers", {}) if request_options is not None else {}),
+                }
+            )
+        )
+
+        if self.logger.is_debug():
+            self.logger.debug(
+                "Making streaming HTTP request",
+                method=method,
+                url=_request_url,
+                headers=_redact_headers(_request_headers),
+            )
+
+        async with self.httpx_client.stream(
+            method=method,
+            url=_request_url,
+            headers=_request_headers,
+            params=_encoded_params if _encoded_params else None,
+            json=json_body,
+            data=data_body,
+            content=content,
+            files=request_files,
+            timeout=timeout,
+        ) as stream:
+            yield stream

venv/lib/python3.12/site-packages/sarvamai/core/http_response.py

@@ -0,0 +1,59 @@
+# This file was auto-generated by Fern from our API Definition.
+
+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")
+
+
+class BaseHttpResponse:
+    """Minimalist HTTP response wrapper that exposes response headers and status code."""
+
+    _response: httpx.Response
+
+    def __init__(self, response: httpx.Response):
+        self._response = response
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        return dict(self._response.headers)
+
+    @property
+    def status_code(self) -> int:
+        return self._response.status_code
+
+
+class HttpResponse(Generic[T], BaseHttpResponse):
+    """HTTP response wrapper that exposes response headers and data."""
+
+    _data: T
+
+    def __init__(self, response: httpx.Response, data: T):
+        super().__init__(response)
+        self._data = data
+
+    @property
+    def data(self) -> T:
+        return self._data
+
+    def close(self) -> None:
+        self._response.close()
+
+
+class AsyncHttpResponse(Generic[T], BaseHttpResponse):
+    """HTTP response wrapper that exposes response headers and data."""
+
+    _data: T
+
+    def __init__(self, response: httpx.Response, data: T):
+        super().__init__(response)
+        self._data = data
+
+    @property
+    def data(self) -> T:
+        return self._data
+
+    async def close(self) -> None:
+        await self._response.aclose()

venv/lib/python3.12/site-packages/sarvamai/core/jsonable_encoder.py

@@ -0,0 +1,108 @@
+# This file was auto-generated by Fern from our API Definition.
+
+"""
+jsonable_encoder converts a Python object to a JSON-friendly dict
+(e.g. datetimes to strings, Pydantic models to dicts).
+
+Taken from FastAPI, and made a bit simpler
+https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
+"""
+
+import base64
+import dataclasses
+import datetime as dt
+from enum import Enum
+from pathlib import PurePath
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Set, Union
+
+import pydantic
+from .datetime_utils import serialize_datetime
+from .pydantic_utilities import (
+    IS_PYDANTIC_V2,
+    encode_by_type,
+    to_jsonable_with_fallback,
+)
+
+SetIntStr = Set[Union[int, str]]
+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)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if isinstance(obj, pydantic.BaseModel):
+        if IS_PYDANTIC_V2:
+            encoder = getattr(obj.model_config, "json_encoders", {})  # type: ignore # Pydantic v2
+        else:
+            encoder = getattr(obj.__config__, "json_encoders", {})  # type: ignore # Pydantic v1
+        if custom_encoder:
+            encoder.update(custom_encoder)
+        obj_dict = obj.dict(by_alias=True)
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        if "root" in obj_dict:
+            obj_dict = obj_dict["root"]
+        return jsonable_encoder(obj_dict, custom_encoder=encoder)
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)  # type: ignore
+        return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
+    if isinstance(obj, bytes):
+        return base64.b64encode(obj).decode("utf-8")
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, dt.datetime):
+        return serialize_datetime(obj)
+    if isinstance(obj, dt.date):
+        return str(obj)
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        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
+        return encoded_dict
+    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
+
+    def fallback_serializer(o: Any) -> Any:
+        attempt_encode = encode_by_type(o)
+        if attempt_encode is not None:
+            return attempt_encode
+
+        try:
+            data = dict(o)
+        except Exception as e:
+            errors: List[Exception] = []
+            errors.append(e)
+            try:
+                data = vars(o)
+            except Exception as e:
+                errors.append(e)
+                raise ValueError(errors) from e
+        return jsonable_encoder(data, custom_encoder=custom_encoder)
+
+    return to_jsonable_with_fallback(obj, fallback_serializer)

venv/lib/python3.12/site-packages/sarvamai/core/logging.py

@@ -0,0 +1,107 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import logging
+import typing
+
+LogLevel = typing.Literal["debug", "info", "warn", "error"]
+
+_LOG_LEVEL_MAP: typing.Dict[LogLevel, int] = {
+    "debug": 1,
+    "info": 2,
+    "warn": 3,
+    "error": 4,
+}
+
+
+class ILogger(typing.Protocol):
+    def debug(self, message: str, **kwargs: typing.Any) -> None: ...
+    def info(self, message: str, **kwargs: typing.Any) -> None: ...
+    def warn(self, message: str, **kwargs: typing.Any) -> None: ...
+    def error(self, message: str, **kwargs: typing.Any) -> None: ...
+
+
+class ConsoleLogger:
+    _logger: logging.Logger
+
+    def __init__(self) -> None:
+        self._logger = logging.getLogger("fern")
+        if not self._logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("%(levelname)s - %(message)s"))
+            self._logger.addHandler(handler)
+            self._logger.setLevel(logging.DEBUG)
+
+    def debug(self, message: str, **kwargs: typing.Any) -> None:
+        self._logger.debug(message, extra=kwargs)
+
+    def info(self, message: str, **kwargs: typing.Any) -> None:
+        self._logger.info(message, extra=kwargs)
+
+    def warn(self, message: str, **kwargs: typing.Any) -> None:
+        self._logger.warning(message, extra=kwargs)
+
+    def error(self, message: str, **kwargs: typing.Any) -> None:
+        self._logger.error(message, extra=kwargs)
+
+
+class LogConfig(typing.TypedDict, total=False):
+    level: LogLevel
+    logger: ILogger
+    silent: bool
+
+
+class Logger:
+    _level: int
+    _logger: ILogger
+    _silent: bool
+
+    def __init__(self, *, level: LogLevel, logger: ILogger, silent: bool) -> None:
+        self._level = _LOG_LEVEL_MAP[level]
+        self._logger = logger
+        self._silent = silent
+
+    def _should_log(self, level: LogLevel) -> bool:
+        return not self._silent and self._level <= _LOG_LEVEL_MAP[level]
+
+    def is_debug(self) -> bool:
+        return self._should_log("debug")
+
+    def is_info(self) -> bool:
+        return self._should_log("info")
+
+    def is_warn(self) -> bool:
+        return self._should_log("warn")
+
+    def is_error(self) -> bool:
+        return self._should_log("error")
+
+    def debug(self, message: str, **kwargs: typing.Any) -> None:
+        if self.is_debug():
+            self._logger.debug(message, **kwargs)
+
+    def info(self, message: str, **kwargs: typing.Any) -> None:
+        if self.is_info():
+            self._logger.info(message, **kwargs)
+
+    def warn(self, message: str, **kwargs: typing.Any) -> None:
+        if self.is_warn():
+            self._logger.warn(message, **kwargs)
+
+    def error(self, message: str, **kwargs: typing.Any) -> None:
+        if self.is_error():
+            self._logger.error(message, **kwargs)
+
+
+_default_logger: Logger = Logger(level="info", logger=ConsoleLogger(), silent=True)
+
+
+def create_logger(config: typing.Optional[typing.Union[LogConfig, Logger]] = None) -> Logger:
+    if config is None:
+        return _default_logger
+    if isinstance(config, Logger):
+        return config
+    return Logger(
+        level=config.get("level", "info"),
+        logger=config.get("logger", ConsoleLogger()),
+        silent=config.get("silent", True),
+    )

venv/lib/python3.12/site-packages/sarvamai/core/pydantic_utilities.py

@@ -0,0 +1,577 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# nopycln: file
+import datetime as dt
+import inspect
+import json
+import logging
+from collections import defaultdict
+from dataclasses import asdict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+import pydantic
+import typing_extensions
+
+_logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from .http_sse._models import ServerSentEvent
+
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+if IS_PYDANTIC_V2:
+    import warnings
+
+    _datetime_adapter = pydantic.TypeAdapter(dt.datetime)  # type: ignore[attr-defined]
+    _date_adapter = pydantic.TypeAdapter(dt.date)  # type: ignore[attr-defined]
+
+    def parse_datetime(value: Any) -> dt.datetime:  # type: ignore[misc]
+        if isinstance(value, dt.datetime):
+            return value
+        return _datetime_adapter.validate_python(value)
+
+    def parse_date(value: Any) -> dt.date:  # type: ignore[misc]
+        if isinstance(value, dt.datetime):
+            return value.date()
+        if isinstance(value, dt.date):
+            return value
+        return _date_adapter.validate_python(value)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", UserWarning)
+        from pydantic.v1.fields import ModelField as ModelField
+        from pydantic.v1.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[attr-defined]
+        from pydantic.v1.typing import get_args as get_args
+        from pydantic.v1.typing import get_origin as get_origin
+        from pydantic.v1.typing import is_literal_type as is_literal_type
+        from pydantic.v1.typing import is_union as is_union
+else:
+    from pydantic.datetime_parse import parse_date as parse_date  # type: ignore[no-redef]
+    from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore[no-redef]
+    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined, no-redef]
+    from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[no-redef]
+    from pydantic.typing import get_args as get_args  # type: ignore[no-redef]
+    from pydantic.typing import get_origin as get_origin  # type: ignore[no-redef]
+    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore[no-redef]
+    from pydantic.typing import is_union as is_union  # type: ignore[no-redef]
+
+from .datetime_utils import serialize_datetime
+from .serialization import convert_and_respect_annotation_metadata
+from typing_extensions import TypeAlias
+
+T = TypeVar("T")
+Model = TypeVar("Model", bound=pydantic.BaseModel)
+
+
+def _get_discriminator_and_variants(type_: Type[Any]) -> Tuple[Optional[str], Optional[List[Type[Any]]]]:
+    """
+    Extract the discriminator field name and union variants from a discriminated union type.
+    Supports Annotated[Union[...], Field(discriminator=...)] patterns.
+    Returns (discriminator, variants) or (None, None) if not a discriminated union.
+    """
+    origin = typing_extensions.get_origin(type_)
+
+    if origin is typing_extensions.Annotated:
+        args = typing_extensions.get_args(type_)
+        if len(args) >= 2:
+            inner_type = args[0]
+            # Check annotations for discriminator
+            discriminator = None
+            for annotation in args[1:]:
+                if hasattr(annotation, "discriminator"):
+                    discriminator = getattr(annotation, "discriminator", None)
+                    break
+
+            if discriminator:
+                inner_origin = typing_extensions.get_origin(inner_type)
+                if inner_origin is Union:
+                    variants = list(typing_extensions.get_args(inner_type))
+                    return discriminator, variants
+    return None, None
+
+
+def _get_field_annotation(model: Type[Any], field_name: str) -> Optional[Type[Any]]:
+    """Get the type annotation of a field from a Pydantic model."""
+    if IS_PYDANTIC_V2:
+        fields = getattr(model, "model_fields", {})
+        field_info = fields.get(field_name)
+        if field_info:
+            return cast(Optional[Type[Any]], field_info.annotation)
+    else:
+        fields = getattr(model, "__fields__", {})
+        field_info = fields.get(field_name)
+        if field_info:
+            return cast(Optional[Type[Any]], field_info.outer_type_)
+    return None
+
+
+def _find_variant_by_discriminator(
+    variants: List[Type[Any]],
+    discriminator: str,
+    discriminator_value: Any,
+) -> Optional[Type[Any]]:
+    """Find the union variant that matches the discriminator value."""
+    for variant in variants:
+        if not (inspect.isclass(variant) and issubclass(variant, pydantic.BaseModel)):
+            continue
+
+        disc_annotation = _get_field_annotation(variant, discriminator)
+        if disc_annotation and is_literal_type(disc_annotation):
+            literal_args = get_args(disc_annotation)
+            if literal_args and literal_args[0] == discriminator_value:
+                return variant
+    return None
+
+
+def _is_string_type(type_: Type[Any]) -> bool:
+    """Check if a type is str or Optional[str]."""
+    if type_ is str:
+        return True
+
+    origin = typing_extensions.get_origin(type_)
+    if origin is Union:
+        args = typing_extensions.get_args(type_)
+        # Optional[str] = Union[str, None]
+        non_none_args = [a for a in args if a is not type(None)]
+        if len(non_none_args) == 1 and non_none_args[0] is str:
+            return True
+
+    return False
+
+
+def parse_sse_obj(sse: "ServerSentEvent", type_: Type[T]) -> T:
+    """
+    Parse a ServerSentEvent into the appropriate type.
+
+    Handles two scenarios based on where the discriminator field is located:
+
+    1. Data-level discrimination: The discriminator (e.g., 'type') is inside the 'data' payload.
+       The union describes the data content, not the SSE envelope.
+       -> Returns: json.loads(data) parsed into the type
+
+       Example: ChatStreamResponse with discriminator='type'
+       Input:  ServerSentEvent(event="message", data='{"type": "content-delta", ...}', id="")
+       Output: ContentDeltaEvent (parsed from data, SSE envelope stripped)
+
+    2. Event-level discrimination: The discriminator (e.g., 'event') is at the SSE event level.
+       The union describes the full SSE event structure.
+       -> Returns: SSE envelope with 'data' field JSON-parsed only if the variant expects non-string
+
+       Example: JobStreamResponse with discriminator='event'
+       Input:  ServerSentEvent(event="ERROR", data='{"code": "FAILED", ...}', id="123")
+       Output: JobStreamResponse_Error with data as ErrorData object
+
+       But for variants where data is str (like STATUS_UPDATE):
+       Input:  ServerSentEvent(event="STATUS_UPDATE", data='{"status": "processing"}', id="1")
+       Output: JobStreamResponse_StatusUpdate with data as string (not parsed)
+
+    Args:
+        sse: The ServerSentEvent object to parse
+        type_: The target discriminated union type
+
+    Returns:
+        The parsed object of type T
+
+    Note:
+        This function is only available in SDK contexts where http_sse module exists.
+    """
+    sse_event = asdict(sse)
+    discriminator, variants = _get_discriminator_and_variants(type_)
+
+    if discriminator is None or variants is None:
+        # Not a discriminated union - parse the data field as JSON
+        data_value = sse_event.get("data")
+        if isinstance(data_value, str) and data_value:
+            try:
+                parsed_data = json.loads(data_value)
+                return parse_obj_as(type_, parsed_data)
+            except json.JSONDecodeError as e:
+                _logger.warning(
+                    "Failed to parse SSE data field as JSON: %s, data: %s",
+                    e,
+                    data_value[:100] if len(data_value) > 100 else data_value,
+                )
+        return parse_obj_as(type_, sse_event)
+
+    data_value = sse_event.get("data")
+
+    # Check if discriminator is at the top level (event-level discrimination)
+    if discriminator in sse_event:
+        # Case 2: Event-level discrimination
+        # Find the matching variant to check if 'data' field needs JSON parsing
+        disc_value = sse_event.get(discriminator)
+        matching_variant = _find_variant_by_discriminator(variants, discriminator, disc_value)
+
+        if matching_variant is not None:
+            # Check what type the variant expects for 'data'
+            data_type = _get_field_annotation(matching_variant, "data")
+            if data_type is not None and not _is_string_type(data_type):
+                # Variant expects non-string data - parse JSON
+                if isinstance(data_value, str) and data_value:
+                    try:
+                        parsed_data = json.loads(data_value)
+                        new_object = dict(sse_event)
+                        new_object["data"] = parsed_data
+                        return parse_obj_as(type_, new_object)
+                    except json.JSONDecodeError as e:
+                        _logger.warning(
+                            "Failed to parse SSE data field as JSON for event-level discrimination: %s, data: %s",
+                            e,
+                            data_value[:100] if len(data_value) > 100 else data_value,
+                        )
+        # Either no matching variant, data is string type, or JSON parse failed
+        return parse_obj_as(type_, sse_event)
+
+    else:
+        # Case 1: Data-level discrimination
+        # The discriminator is inside the data payload - extract and parse data only
+        if isinstance(data_value, str) and data_value:
+            try:
+                parsed_data = json.loads(data_value)
+                return parse_obj_as(type_, parsed_data)
+            except json.JSONDecodeError as e:
+                _logger.warning(
+                    "Failed to parse SSE data field as JSON for data-level discrimination: %s, data: %s",
+                    e,
+                    data_value[:100] if len(data_value) > 100 else data_value,
+                )
+        return parse_obj_as(type_, sse_event)
+
+
+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")
+    if IS_PYDANTIC_V2:
+        adapter = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
+        return adapter.validate_python(dealiased_object)
+    return pydantic.parse_obj_as(type_, dealiased_object)
+
+
+def to_jsonable_with_fallback(obj: Any, fallback_serializer: Callable[[Any], Any]) -> Any:
+    if IS_PYDANTIC_V2:
+        from pydantic_core import to_jsonable_python
+
+        return to_jsonable_python(obj, fallback=fallback_serializer)
+    return fallback_serializer(obj)
+
+
+class UniversalBaseModel(pydantic.BaseModel):
+    if IS_PYDANTIC_V2:
+        model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(  # type: ignore[typeddict-unknown-key]
+            # Allow fields beginning with `model_` to be used in the model
+            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]
+            data = {k: serialize_datetime(v) if isinstance(v, dt.datetime) else v for k, v in serialized.items()}
+            return data
+
+    else:
+
+        class Config:
+            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")
+        return cls.construct(_fields_set, **dealiased_object)
+
+    @classmethod
+    def 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")
+        if IS_PYDANTIC_V2:
+            return super().model_construct(_fields_set, **dealiased_object)  # type: ignore[misc]
+        return super().construct(_fields_set, **dealiased_object)
+
+    def json(self, **kwargs: Any) -> str:
+        kwargs_with_defaults = {
+            "by_alias": True,
+            "exclude_unset": True,
+            **kwargs,
+        }
+        if IS_PYDANTIC_V2:
+            return super().model_dump_json(**kwargs_with_defaults)  # type: ignore[misc]
+        return super().json(**kwargs_with_defaults)
+
+    def dict(self, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Override the default dict method to `exclude_unset` by default. This function patches
+        `exclude_unset` to work include fields within non-None default values.
+        """
+        # Note: the logic here is multiplexed given the levers exposed in Pydantic V1 vs V2
+        # Pydantic V1's .dict can be extremely slow, so we do not want to call it twice.
+        #
+        # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
+        # that we have less control over, and this is less intrusive than custom serializers for now.
+        if IS_PYDANTIC_V2:
+            kwargs_with_defaults_exclude_unset = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_unset": True,
+                "exclude_none": False,
+            }
+            kwargs_with_defaults_exclude_none = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_none": True,
+                "exclude_unset": False,
+            }
+            dict_dump = deep_union_pydantic_dicts(
+                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore[misc]
+                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore[misc]
+            )
+
+        else:
+            _fields_set = self.__fields_set__.copy()
+
+            fields = _get_model_fields(self.__class__)
+            for name, field in fields.items():
+                if name not in _fields_set:
+                    default = _get_field_default(field)
+
+                    # If the default values are non-null act like they've been set
+                    # This effectively allows exclude_unset to work like exclude_none where
+                    # the latter passes through intentionally set none values.
+                    if default is not None or ("exclude_unset" in kwargs and not kwargs["exclude_unset"]):
+                        _fields_set.add(name)
+
+                        if default is not None:
+                            self.__fields_set__.add(name)
+
+            kwargs_with_defaults_exclude_unset_include_fields = {
+                "by_alias": True,
+                "exclude_unset": True,
+                "include": _fields_set,
+                **kwargs,
+            }
+
+            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"),
+        )
+
+
+def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:
+    converted_list: List[Any] = []
+    for i, item in enumerate(source):
+        destination_value = destination[i]
+        if isinstance(item, dict):
+            converted_list.append(deep_union_pydantic_dicts(item, destination_value))
+        elif isinstance(item, list):
+            converted_list.append(_union_list_of_pydantic_dicts(item, destination_value))
+        else:
+            converted_list.append(item)
+    return converted_list
+
+
+def deep_union_pydantic_dicts(source: Dict[str, Any], destination: Dict[str, Any]) -> Dict[str, Any]:
+    for key, value in source.items():
+        node = destination.setdefault(key, {})
+        if isinstance(value, dict):
+            deep_union_pydantic_dicts(value, node)
+        # Note: we do not do this same processing for sets given we do not have sets of models
+        # and given the sets are unordered, the processing of the set and matching objects would
+        # be non-trivial.
+        elif isinstance(value, list):
+            destination[key] = _union_list_of_pydantic_dicts(value, node)
+        else:
+            destination[key] = value
+
+    return destination
+
+
+if IS_PYDANTIC_V2:
+
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore[misc, name-defined, type-arg]
+        pass
+
+    UniversalRootModel: TypeAlias = V2RootModel  # type: ignore[misc]
+else:
+    UniversalRootModel: TypeAlias = UniversalBaseModel  # type: ignore[misc, no-redef]
+
+
+def encode_by_type(o: Any) -> Any:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+    for type_, encoder in encoders_by_type.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+
+    if type(o) in encoders_by_type:
+        return encoders_by_type[type(o)](o)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(o, classes_tuple):
+            return encoder(o)
+
+
+def update_forward_refs(model: Type["Model"], **localns: Any) -> None:
+    if IS_PYDANTIC_V2:
+        model.model_rebuild(raise_errors=False)  # type: ignore[attr-defined]
+    else:
+        model.update_forward_refs(**localns)
+
+
+# Mirrors Pydantic's internal typing
+AnyCallable = Callable[..., Any]
+
+
+def universal_root_validator(
+    pre: bool = False,
+) -> 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.root_validator(pre=pre)(func))  # type: ignore[call-overload]
+
+    return decorator
+
+
+def universal_field_validator(field_name: str, pre: bool = False) -> Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        if IS_PYDANTIC_V2:
+            return cast(AnyCallable, pydantic.field_validator(field_name, mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
+        return cast(AnyCallable, pydantic.validator(field_name, pre=pre)(func))
+
+    return decorator
+
+
+PydanticField = Union[ModelField, pydantic.fields.FieldInfo]
+
+
+def _get_model_fields(model: Type["Model"]) -> Mapping[str, PydanticField]:
+    if IS_PYDANTIC_V2:
+        return cast(Mapping[str, PydanticField], model.model_fields)  # type: ignore[attr-defined]
+    return cast(Mapping[str, PydanticField], model.__fields__)
+
+
+def _get_field_default(field: PydanticField) -> Any:
+    try:
+        value = field.get_default()  # type: ignore[union-attr]
+    except:
+        value = field.default
+    if IS_PYDANTIC_V2:
+        from pydantic_core import PydanticUndefined
+
+        if value == PydanticUndefined:
+            return None
+        return value
+    return value

venv/lib/python3.12/site-packages/sarvamai/core/query_encoder.py

@@ -0,0 +1,58 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, List, Optional, Tuple
+
+import pydantic
+
+
+# Flattens dicts to be of the form {"key[subkey][subkey2]": value} where value is not a dict
+def traverse_query_dict(dict_flat: Dict[str, Any], key_prefix: Optional[str] = None) -> List[Tuple[str, Any]]:
+    result = []
+    for k, v in dict_flat.items():
+        key = f"{key_prefix}[{k}]" if key_prefix is not None else k
+        if isinstance(v, dict):
+            result.extend(traverse_query_dict(v, key))
+        elif isinstance(v, list):
+            for arr_v in v:
+                if isinstance(arr_v, dict):
+                    result.extend(traverse_query_dict(arr_v, key))
+                else:
+                    result.append((key, arr_v))
+        else:
+            result.append((key, v))
+    return result
+
+
+def single_query_encoder(query_key: str, query_value: Any) -> List[Tuple[str, Any]]:
+    if isinstance(query_value, pydantic.BaseModel) or isinstance(query_value, dict):
+        if isinstance(query_value, pydantic.BaseModel):
+            obj_dict = query_value.dict(by_alias=True)
+        else:
+            obj_dict = query_value
+        return traverse_query_dict(obj_dict, query_key)
+    elif isinstance(query_value, list):
+        encoded_values: List[Tuple[str, Any]] = []
+        for value in query_value:
+            if isinstance(value, pydantic.BaseModel) or isinstance(value, dict):
+                if isinstance(value, pydantic.BaseModel):
+                    obj_dict = value.dict(by_alias=True)
+                elif isinstance(value, dict):
+                    obj_dict = value
+
+                encoded_values.extend(single_query_encoder(query_key, obj_dict))
+            else:
+                encoded_values.append((query_key, value))
+
+        return encoded_values
+
+    return [(query_key, query_value)]
+
+
+def encode_query(query: Optional[Dict[str, Any]]) -> Optional[List[Tuple[str, Any]]]:
+    if query is None:
+        return None
+
+    encoded_query = []
+    for k, v in query.items():
+        encoded_query.extend(single_query_encoder(k, v))
+    return encoded_query

venv/lib/python3.12/site-packages/sarvamai/core/remove_none_from_dict.py

@@ -0,0 +1,11 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, Mapping, Optional
+
+
+def remove_none_from_dict(original: Mapping[str, Optional[Any]]) -> Dict[str, Any]:
+    new: Dict[str, Any] = {}
+    for key, value in original.items():
+        if value is not None:
+            new[key] = value
+    return new

venv/lib/python3.12/site-packages/sarvamai/core/request_options.py

@@ -0,0 +1,35 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+try:
+    from typing import NotRequired  # type: ignore
+except ImportError:
+    from typing_extensions import NotRequired
+
+
+class RequestOptions(typing.TypedDict, total=False):
+    """
+    Additional options for request-specific configuration when calling APIs via the SDK.
+    This is used primarily as an optional final parameter for service functions.
+
+    Attributes:
+        - timeout_in_seconds: int. The number of seconds to await an API call before timing out.
+
+        - max_retries: int. The max number of retries to attempt if the API call fails.
+
+        - additional_headers: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's header dict
+
+        - additional_query_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's query parameters dict
+
+        - additional_body_parameters: typing.Dict[str, typing.Any]. A dictionary containing additional parameters to spread into the request's body parameters dict
+
+        - chunk_size: int. The size, in bytes, to process each chunk of data being streamed back within the response. This equates to leveraging `chunk_size` within `requests` or `httpx`, and is only leveraged for file downloads.
+    """
+
+    timeout_in_seconds: NotRequired[int]
+    max_retries: NotRequired[int]
+    additional_headers: NotRequired[typing.Dict[str, typing.Any]]
+    additional_query_parameters: NotRequired[typing.Dict[str, typing.Any]]
+    additional_body_parameters: NotRequired[typing.Dict[str, typing.Any]]
+    chunk_size: NotRequired[int]

venv/lib/python3.12/site-packages/sarvamai/core/serialization.py

@@ -0,0 +1,276 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import collections
+import inspect
+import typing
+
+import pydantic
+import typing_extensions
+
+
+class FieldMetadata:
+    """
+    Metadata class used to annotate fields to provide additional information.
+
+    Example:
+    class MyDict(TypedDict):
+        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
+
+    Will serialize: `{"field": "value"}`
+    To: `{"field_name": "value"}`
+    """
+
+    alias: str
+
+    def __init__(self, *, alias: str) -> None:
+        self.alias = alias
+
+
+def convert_and_respect_annotation_metadata(
+    *,
+    object_: typing.Any,
+    annotation: typing.Any,
+    inner_type: typing.Optional[typing.Any] = None,
+    direction: typing.Literal["read", "write"],
+) -> typing.Any:
+    """
+    Respect the metadata annotations on a field, such as aliasing. This function effectively
+    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
+    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
+    utilities, such as defaults.
+
+    Parameters
+    ----------
+    object_ : typing.Any
+
+    annotation : type
+        The type we're looking to apply typing annotations from
+
+    inner_type : typing.Optional[type]
+
+    Returns
+    -------
+    typing.Any
+    """
+
+    if object_ is None:
+        return None
+    if inner_type is None:
+        inner_type = annotation
+
+    clean_type = _remove_annotations(inner_type)
+    # Pydantic models
+    if (
+        inspect.isclass(clean_type)
+        and issubclass(clean_type, pydantic.BaseModel)
+        and isinstance(object_, typing.Mapping)
+    ):
+        return _convert_mapping(object_, clean_type, direction)
+    # TypedDicts
+    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
+        return _convert_mapping(object_, clean_type, direction)
+
+    if (
+        typing_extensions.get_origin(clean_type) == typing.Dict
+        or typing_extensions.get_origin(clean_type) == dict
+        or clean_type == typing.Dict
+    ) and isinstance(object_, typing.Dict):
+        key_type = typing_extensions.get_args(clean_type)[0]
+        value_type = typing_extensions.get_args(clean_type)[1]
+
+        return {
+            key: convert_and_respect_annotation_metadata(
+                object_=value,
+                annotation=annotation,
+                inner_type=value_type,
+                direction=direction,
+            )
+            for key, value in object_.items()
+        }
+
+    # If you're iterating on a string, do not bother to coerce it to a sequence.
+    if not isinstance(object_, str):
+        if (
+            typing_extensions.get_origin(clean_type) == typing.Set
+            or typing_extensions.get_origin(clean_type) == set
+            or clean_type == typing.Set
+        ) and isinstance(object_, typing.Set):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return {
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            }
+        elif (
+            (
+                typing_extensions.get_origin(clean_type) == typing.List
+                or typing_extensions.get_origin(clean_type) == list
+                or clean_type == typing.List
+            )
+            and isinstance(object_, typing.List)
+        ) or (
+            (
+                typing_extensions.get_origin(clean_type) == typing.Sequence
+                or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
+                or clean_type == typing.Sequence
+            )
+            and isinstance(object_, typing.Sequence)
+        ):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return [
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            ]
+
+    if typing_extensions.get_origin(clean_type) == typing.Union:
+        # We should be able to ~relatively~ safely try to convert keys against all
+        # member types in the union, the edge case here is if one member aliases a field
+        # of the same name to a different name from another member
+        # Or if another member aliases a field of the same name that another member does not.
+        for member in typing_extensions.get_args(clean_type):
+            object_ = convert_and_respect_annotation_metadata(
+                object_=object_,
+                annotation=annotation,
+                inner_type=member,
+                direction=direction,
+            )
+        return object_
+
+    annotated_type = _get_annotation(annotation)
+    if annotated_type is None:
+        return object_
+
+    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
+    # Then we can safely call it on the recursive conversion.
+    return object_
+
+
+def _convert_mapping(
+    object_: typing.Mapping[str, object],
+    expected_type: typing.Any,
+    direction: typing.Literal["read", "write"],
+) -> typing.Mapping[str, object]:
+    converted_object: typing.Dict[str, object] = {}
+    try:
+        annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
+    except NameError:
+        # The TypedDict contains a circular reference, so
+        # we use the __annotations__ attribute directly.
+        annotations = getattr(expected_type, "__annotations__", {})
+    aliases_to_field_names = _get_alias_to_field_name(annotations)
+    for key, value in object_.items():
+        if direction == "read" and key in aliases_to_field_names:
+            dealiased_key = aliases_to_field_names.get(key)
+            if dealiased_key is not None:
+                type_ = annotations.get(dealiased_key)
+        else:
+            type_ = annotations.get(key)
+        # Note you can't get the annotation by the field name if you're in read mode, so you must check the aliases map
+        #
+        # So this is effectively saying if we're in write mode, and we don't have a type, or if we're in read mode and we don't have an alias
+        # then we can just pass the value through as is
+        if type_ is None:
+            converted_object[key] = value
+        elif direction == "read" and key not in aliases_to_field_names:
+            converted_object[key] = convert_and_respect_annotation_metadata(
+                object_=value, annotation=type_, direction=direction
+            )
+        else:
+            converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
+                convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
+            )
+    return converted_object
+
+
+def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return None
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        type_ = typing_extensions.get_args(type_)[0]
+        maybe_annotated_type = typing_extensions.get_origin(type_)
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return type_
+
+    return None
+
+
+def _remove_annotations(type_: typing.Any) -> typing.Any:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return type_
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    return type_
+
+
+def get_alias_to_field_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_alias_to_field_name(annotations)
+
+
+def get_field_to_alias_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_field_to_alias_name(annotations)
+
+
+def _get_alias_to_field_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[maybe_alias] = field
+    return aliases
+
+
+def _get_field_to_alias_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[field] = maybe_alias
+    return aliases
+
+
+def _get_alias_from_type(type_: typing.Any) -> typing.Optional[str]:
+    maybe_annotated_type = _get_annotation(type_)
+
+    if maybe_annotated_type is not None:
+        # The actual annotations are 1 onward, the first is the annotated type
+        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
+
+        for annotation in annotations:
+            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
+                return annotation.alias
+    return None
+
+
+def _alias_key(
+    key: str,
+    type_: typing.Any,
+    direction: typing.Literal["read", "write"],
+    aliases_to_field_names: typing.Dict[str, str],
+) -> str:
+    if direction == "read":
+        return aliases_to_field_names.get(key, key)
+    return _get_alias_from_type(type_=type_) or key

venv/lib/python3.12/site-packages/sarvamai/core/websocket_compat.py

@@ -0,0 +1,13 @@
+# This file was auto-generated by Fern from our API Definition.
+
+try:
+    from websockets.exceptions import InvalidStatusCode as InvalidWebSocketStatus  # type: ignore[attr-defined]
+
+    def get_status_code(exc: InvalidWebSocketStatus) -> int:
+        return exc.status_code  # type: ignore[attr-defined, union-attr]
+
+except ImportError:
+    from websockets.exceptions import InvalidStatus as InvalidWebSocketStatus  # type: ignore[assignment, no-redef]
+
+    def get_status_code(exc: InvalidWebSocketStatus) -> int:  # type: ignore[no-redef]
+        return exc.response.status_code  # type: ignore[attr-defined, union-attr]

venv/lib/python3.12/site-packages/sarvamai/document_intelligence/__init__.py

@@ -0,0 +1,4 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+