scale-gp-beta 0.1.0a3__py3-none-any.whl → 0.1.0a5__py3-none-any.whl

scale_gp_beta/_base_client.py

@@ -9,7 +9,6 @@ import asyncio
 import inspect
 import logging
 import platform
-import warnings
 import email.utils
 from types import TracebackType
 from random import random
@@ -36,7 +35,7 @@ import anyio
 import httpx
 import distro
 import pydantic
-from httpx import URL, Limits
+from httpx import URL
 from pydantic import PrivateAttr
 
 from . import _exceptions
@@ -51,13 +50,10 @@ from ._types import (
     Timeout,
     NotGiven,
     ResponseT,
-    Transport,
     AnyMapping,
     PostParser,
-    ProxiesTypes,
     RequestFiles,
     HttpxSendArgs,
-    AsyncTransport,
     RequestOptions,
     HttpxRequestFiles,
     ModelBuilderProtocol,
@@ -337,9 +333,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
     _base_url: URL
     max_retries: int
     timeout: Union[float, Timeout, None]
-    _limits: httpx.Limits
-    _proxies: ProxiesTypes | None
-    _transport: Transport | AsyncTransport | None
     _strict_response_validation: bool
     _idempotency_header: str | None
     _default_stream_cls: type[_DefaultStreamT] | None = None
@@ -352,9 +345,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         _strict_response_validation: bool,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float | Timeout | None = DEFAULT_TIMEOUT,
-        limits: httpx.Limits,
-        transport: Transport | AsyncTransport | None,
-        proxies: ProxiesTypes | None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
     ) -> None:
@@ -362,9 +352,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         self._base_url = self._enforce_trailing_slash(URL(base_url))
         self.max_retries = max_retries
         self.timeout = timeout
-        self._limits = limits
-        self._proxies = proxies
-        self._transport = transport
         self._custom_headers = custom_headers or {}
         self._custom_query = custom_query or {}
         self._strict_response_validation = _strict_response_validation
@@ -800,46 +787,11 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         base_url: str | URL,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
-        transport: Transport | None = None,
-        proxies: ProxiesTypes | None = None,
-        limits: Limits | None = None,
         http_client: httpx.Client | None = None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
         _strict_response_validation: bool,
     ) -> None:
-        kwargs: dict[str, Any] = {}
-        if limits is not None:
-            warnings.warn(
-                "The `connection_pool_limits` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `connection_pool_limits`")
-        else:
-            limits = DEFAULT_CONNECTION_LIMITS
-
-        if transport is not None:
-            kwargs["transport"] = transport
-            warnings.warn(
-                "The `transport` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `transport`")
-
-        if proxies is not None:
-            kwargs["proxies"] = proxies
-            warnings.warn(
-                "The `proxies` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `proxies`")
-
         if not is_given(timeout):
             # if the user passed in a custom http client with a non-default
             # timeout set then we use that timeout.
@@ -860,12 +812,9 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
 
         super().__init__(
             version=version,
-            limits=limits,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            proxies=proxies,
             base_url=base_url,
-            transport=transport,
             max_retries=max_retries,
             custom_query=custom_query,
             custom_headers=custom_headers,
@@ -875,9 +824,6 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
             base_url=base_url,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            limits=limits,
-            follow_redirects=True,
-            **kwargs,  # type: ignore
         )
 
     def is_closed(self) -> bool:
@@ -1372,45 +1318,10 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         _strict_response_validation: bool,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
-        transport: AsyncTransport | None = None,
-        proxies: ProxiesTypes | None = None,
-        limits: Limits | None = None,
         http_client: httpx.AsyncClient | None = None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
     ) -> None:
-        kwargs: dict[str, Any] = {}
-        if limits is not None:
-            warnings.warn(
-                "The `connection_pool_limits` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `connection_pool_limits`")
-        else:
-            limits = DEFAULT_CONNECTION_LIMITS
-
-        if transport is not None:
-            kwargs["transport"] = transport
-            warnings.warn(
-                "The `transport` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `transport`")
-
-        if proxies is not None:
-            kwargs["proxies"] = proxies
-            warnings.warn(
-                "The `proxies` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `proxies`")
-
         if not is_given(timeout):
             # if the user passed in a custom http client with a non-default
             # timeout set then we use that timeout.
@@ -1432,11 +1343,8 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         super().__init__(
             version=version,
             base_url=base_url,
-            limits=limits,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            proxies=proxies,
-            transport=transport,
             max_retries=max_retries,
             custom_query=custom_query,
             custom_headers=custom_headers,
@@ -1446,9 +1354,6 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
             base_url=base_url,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            limits=limits,
-            follow_redirects=True,
-            **kwargs,  # type: ignore
         )
 
     def is_closed(self) -> bool:

scale_gp_beta/_client.py

@@ -24,7 +24,7 @@ from ._utils import (
     get_async_library,
 )
 from ._version import __version__
-from .resources import models, inference, questions, completions, question_sets
+from .resources import models, datasets, inference, completions, evaluations
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, SGPClientError
 from ._base_client import (
@@ -57,10 +57,10 @@ class SGPClient(SyncAPIClient):
     completions: completions.CompletionsResource
     chat: chat.ChatResource
     inference: inference.InferenceResource
-    questions: questions.QuestionsResource
-    question_sets: question_sets.QuestionSetsResource
     files: files.FilesResource
     models: models.ModelsResource
+    datasets: datasets.DatasetsResource
+    evaluations: evaluations.EvaluationsResource
     with_raw_response: SGPClientWithRawResponse
     with_streaming_response: SGPClientWithStreamedResponse
 
@@ -157,10 +157,10 @@ class SGPClient(SyncAPIClient):
         self.completions = completions.CompletionsResource(self)
         self.chat = chat.ChatResource(self)
         self.inference = inference.InferenceResource(self)
-        self.questions = questions.QuestionsResource(self)
-        self.question_sets = question_sets.QuestionSetsResource(self)
         self.files = files.FilesResource(self)
         self.models = models.ModelsResource(self)
+        self.datasets = datasets.DatasetsResource(self)
+        self.evaluations = evaluations.EvaluationsResource(self)
         self.with_raw_response = SGPClientWithRawResponse(self)
         self.with_streaming_response = SGPClientWithStreamedResponse(self)
 
@@ -278,10 +278,10 @@ class AsyncSGPClient(AsyncAPIClient):
     completions: completions.AsyncCompletionsResource
     chat: chat.AsyncChatResource
     inference: inference.AsyncInferenceResource
-    questions: questions.AsyncQuestionsResource
-    question_sets: question_sets.AsyncQuestionSetsResource
     files: files.AsyncFilesResource
     models: models.AsyncModelsResource
+    datasets: datasets.AsyncDatasetsResource
+    evaluations: evaluations.AsyncEvaluationsResource
     with_raw_response: AsyncSGPClientWithRawResponse
     with_streaming_response: AsyncSGPClientWithStreamedResponse
 
@@ -378,10 +378,10 @@ class AsyncSGPClient(AsyncAPIClient):
         self.completions = completions.AsyncCompletionsResource(self)
         self.chat = chat.AsyncChatResource(self)
         self.inference = inference.AsyncInferenceResource(self)
-        self.questions = questions.AsyncQuestionsResource(self)
-        self.question_sets = question_sets.AsyncQuestionSetsResource(self)
         self.files = files.AsyncFilesResource(self)
         self.models = models.AsyncModelsResource(self)
+        self.datasets = datasets.AsyncDatasetsResource(self)
+        self.evaluations = evaluations.AsyncEvaluationsResource(self)
         self.with_raw_response = AsyncSGPClientWithRawResponse(self)
         self.with_streaming_response = AsyncSGPClientWithStreamedResponse(self)
 
@@ -500,10 +500,10 @@ class SGPClientWithRawResponse:
         self.completions = completions.CompletionsResourceWithRawResponse(client.completions)
         self.chat = chat.ChatResourceWithRawResponse(client.chat)
         self.inference = inference.InferenceResourceWithRawResponse(client.inference)
-        self.questions = questions.QuestionsResourceWithRawResponse(client.questions)
-        self.question_sets = question_sets.QuestionSetsResourceWithRawResponse(client.question_sets)
         self.files = files.FilesResourceWithRawResponse(client.files)
         self.models = models.ModelsResourceWithRawResponse(client.models)
+        self.datasets = datasets.DatasetsResourceWithRawResponse(client.datasets)
+        self.evaluations = evaluations.EvaluationsResourceWithRawResponse(client.evaluations)
 
 
 class AsyncSGPClientWithRawResponse:
@@ -511,10 +511,10 @@ class AsyncSGPClientWithRawResponse:
         self.completions = completions.AsyncCompletionsResourceWithRawResponse(client.completions)
         self.chat = chat.AsyncChatResourceWithRawResponse(client.chat)
         self.inference = inference.AsyncInferenceResourceWithRawResponse(client.inference)
-        self.questions = questions.AsyncQuestionsResourceWithRawResponse(client.questions)
-        self.question_sets = question_sets.AsyncQuestionSetsResourceWithRawResponse(client.question_sets)
         self.files = files.AsyncFilesResourceWithRawResponse(client.files)
         self.models = models.AsyncModelsResourceWithRawResponse(client.models)
+        self.datasets = datasets.AsyncDatasetsResourceWithRawResponse(client.datasets)
+        self.evaluations = evaluations.AsyncEvaluationsResourceWithRawResponse(client.evaluations)
 
 
 class SGPClientWithStreamedResponse:
@@ -522,10 +522,10 @@ class SGPClientWithStreamedResponse:
         self.completions = completions.CompletionsResourceWithStreamingResponse(client.completions)
         self.chat = chat.ChatResourceWithStreamingResponse(client.chat)
         self.inference = inference.InferenceResourceWithStreamingResponse(client.inference)
-        self.questions = questions.QuestionsResourceWithStreamingResponse(client.questions)
-        self.question_sets = question_sets.QuestionSetsResourceWithStreamingResponse(client.question_sets)
         self.files = files.FilesResourceWithStreamingResponse(client.files)
         self.models = models.ModelsResourceWithStreamingResponse(client.models)
+        self.datasets = datasets.DatasetsResourceWithStreamingResponse(client.datasets)
+        self.evaluations = evaluations.EvaluationsResourceWithStreamingResponse(client.evaluations)
 
 
 class AsyncSGPClientWithStreamedResponse:
@@ -533,10 +533,10 @@ class AsyncSGPClientWithStreamedResponse:
         self.completions = completions.AsyncCompletionsResourceWithStreamingResponse(client.completions)
         self.chat = chat.AsyncChatResourceWithStreamingResponse(client.chat)
         self.inference = inference.AsyncInferenceResourceWithStreamingResponse(client.inference)
-        self.questions = questions.AsyncQuestionsResourceWithStreamingResponse(client.questions)
-        self.question_sets = question_sets.AsyncQuestionSetsResourceWithStreamingResponse(client.question_sets)
         self.files = files.AsyncFilesResourceWithStreamingResponse(client.files)
         self.models = models.AsyncModelsResourceWithStreamingResponse(client.models)
+        self.datasets = datasets.AsyncDatasetsResourceWithStreamingResponse(client.datasets)
+        self.evaluations = evaluations.AsyncEvaluationsResourceWithStreamingResponse(client.evaluations)
 
 
 Client = SGPClient

scale_gp_beta/_models.py

@@ -65,7 +65,7 @@ from ._compat import (
 from ._constants import RAW_RESPONSE_HEADER
 
 if TYPE_CHECKING:
-    from pydantic_core.core_schema import ModelField, LiteralSchema, ModelFieldsSchema
+    from pydantic_core.core_schema import ModelField, ModelSchema, LiteralSchema, ModelFieldsSchema
 
 __all__ = ["BaseModel", "GenericModel"]
 
@@ -646,15 +646,18 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
 
 def _extract_field_schema_pv2(model: type[BaseModel], field_name: str) -> ModelField | None:
     schema = model.__pydantic_core_schema__
+    if schema["type"] == "definitions":
+        schema = schema["schema"]
+
     if schema["type"] != "model":
         return None
 
+    schema = cast("ModelSchema", schema)
     fields_schema = schema["schema"]
     if fields_schema["type"] != "model-fields":
         return None
 
     fields_schema = cast("ModelFieldsSchema", fields_schema)
-
     field = fields_schema["fields"].get(field_name)
     if not field:
         return None

scale_gp_beta/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "scale_gp_beta"
-__version__ = "0.1.0-alpha.3"  # x-release-please-version
+__version__ = "0.1.0-alpha.5"  # x-release-please-version

scale_gp_beta/resources/__init__.py

@@ -24,6 +24,14 @@ from .models import (
     ModelsResourceWithStreamingResponse,
     AsyncModelsResourceWithStreamingResponse,
 )
+from .datasets import (
+    DatasetsResource,
+    AsyncDatasetsResource,
+    DatasetsResourceWithRawResponse,
+    AsyncDatasetsResourceWithRawResponse,
+    DatasetsResourceWithStreamingResponse,
+    AsyncDatasetsResourceWithStreamingResponse,
+)
 from .inference import (
     InferenceResource,
     AsyncInferenceResource,
@@ -32,14 +40,6 @@ from .inference import (
     InferenceResourceWithStreamingResponse,
     AsyncInferenceResourceWithStreamingResponse,
 )
-from .questions import (
-    QuestionsResource,
-    AsyncQuestionsResource,
-    QuestionsResourceWithRawResponse,
-    AsyncQuestionsResourceWithRawResponse,
-    QuestionsResourceWithStreamingResponse,
-    AsyncQuestionsResourceWithStreamingResponse,
-)
 from .completions import (
     CompletionsResource,
     AsyncCompletionsResource,
@@ -48,13 +48,13 @@ from .completions import (
     CompletionsResourceWithStreamingResponse,
     AsyncCompletionsResourceWithStreamingResponse,
 )
-from .question_sets import (
-    QuestionSetsResource,
-    AsyncQuestionSetsResource,
-    QuestionSetsResourceWithRawResponse,
-    AsyncQuestionSetsResourceWithRawResponse,
-    QuestionSetsResourceWithStreamingResponse,
-    AsyncQuestionSetsResourceWithStreamingResponse,
+from .evaluations import (
+    EvaluationsResource,
+    AsyncEvaluationsResource,
+    EvaluationsResourceWithRawResponse,
+    AsyncEvaluationsResourceWithRawResponse,
+    EvaluationsResourceWithStreamingResponse,
+    AsyncEvaluationsResourceWithStreamingResponse,
 )
 
 __all__ = [
@@ -76,18 +76,6 @@ __all__ = [
     "AsyncInferenceResourceWithRawResponse",
     "InferenceResourceWithStreamingResponse",
     "AsyncInferenceResourceWithStreamingResponse",
-    "QuestionsResource",
-    "AsyncQuestionsResource",
-    "QuestionsResourceWithRawResponse",
-    "AsyncQuestionsResourceWithRawResponse",
-    "QuestionsResourceWithStreamingResponse",
-    "AsyncQuestionsResourceWithStreamingResponse",
-    "QuestionSetsResource",
-    "AsyncQuestionSetsResource",
-    "QuestionSetsResourceWithRawResponse",
-    "AsyncQuestionSetsResourceWithRawResponse",
-    "QuestionSetsResourceWithStreamingResponse",
-    "AsyncQuestionSetsResourceWithStreamingResponse",
     "FilesResource",
     "AsyncFilesResource",
     "FilesResourceWithRawResponse",
@@ -100,4 +88,16 @@ __all__ = [
     "AsyncModelsResourceWithRawResponse",
     "ModelsResourceWithStreamingResponse",
     "AsyncModelsResourceWithStreamingResponse",
+    "DatasetsResource",
+    "AsyncDatasetsResource",
+    "DatasetsResourceWithRawResponse",
+    "AsyncDatasetsResourceWithRawResponse",
+    "DatasetsResourceWithStreamingResponse",
+    "AsyncDatasetsResourceWithStreamingResponse",
+    "EvaluationsResource",
+    "AsyncEvaluationsResource",
+    "EvaluationsResourceWithRawResponse",
+    "AsyncEvaluationsResourceWithRawResponse",
+    "EvaluationsResourceWithStreamingResponse",
+    "AsyncEvaluationsResourceWithStreamingResponse",
 ]

scale_gp_beta/resources/chat/completions.py

@@ -474,53 +474,50 @@ class CompletionsResource(SyncAPIResource):
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> CompletionCreateResponse | Stream[ChatCompletionChunk]:
-        return cast(
-            CompletionCreateResponse,
-            self._post(
-                "/v5/chat/completions",
-                body=maybe_transform(
-                    {
-                        "messages": messages,
-                        "model": model,
-                        "audio": audio,
-                        "frequency_penalty": frequency_penalty,
-                        "function_call": function_call,
-                        "functions": functions,
-                        "logit_bias": logit_bias,
-                        "logprobs": logprobs,
-                        "max_completion_tokens": max_completion_tokens,
-                        "max_tokens": max_tokens,
-                        "metadata": metadata,
-                        "modalities": modalities,
-                        "n": n,
-                        "parallel_tool_calls": parallel_tool_calls,
-                        "prediction": prediction,
-                        "presence_penalty": presence_penalty,
-                        "reasoning_effort": reasoning_effort,
-                        "response_format": response_format,
-                        "seed": seed,
-                        "stop": stop,
-                        "store": store,
-                        "stream": stream,
-                        "stream_options": stream_options,
-                        "temperature": temperature,
-                        "tool_choice": tool_choice,
-                        "tools": tools,
-                        "top_k": top_k,
-                        "top_logprobs": top_logprobs,
-                        "top_p": top_p,
-                    },
-                    completion_create_params.CompletionCreateParams,
-                ),
-                options=make_request_options(
-                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-                ),
-                cast_to=cast(
-                    Any, CompletionCreateResponse
-                ),  # Union types cannot be passed in as arguments in the type system
-                stream=stream or False,
-                stream_cls=Stream[ChatCompletionChunk],
+        return self._post(
+            "/v5/chat/completions",
+            body=maybe_transform(
+                {
+                    "messages": messages,
+                    "model": model,
+                    "audio": audio,
+                    "frequency_penalty": frequency_penalty,
+                    "function_call": function_call,
+                    "functions": functions,
+                    "logit_bias": logit_bias,
+                    "logprobs": logprobs,
+                    "max_completion_tokens": max_completion_tokens,
+                    "max_tokens": max_tokens,
+                    "metadata": metadata,
+                    "modalities": modalities,
+                    "n": n,
+                    "parallel_tool_calls": parallel_tool_calls,
+                    "prediction": prediction,
+                    "presence_penalty": presence_penalty,
+                    "reasoning_effort": reasoning_effort,
+                    "response_format": response_format,
+                    "seed": seed,
+                    "stop": stop,
+                    "store": store,
+                    "stream": stream,
+                    "stream_options": stream_options,
+                    "temperature": temperature,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "top_k": top_k,
+                    "top_logprobs": top_logprobs,
+                    "top_p": top_p,
+                },
+                completion_create_params.CompletionCreateParams,
             ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=cast(
+                Any, CompletionCreateResponse
+            ),  # Union types cannot be passed in as arguments in the type system
+            stream=stream or False,
+            stream_cls=Stream[ChatCompletionChunk],
         )
 
 
@@ -968,53 +965,50 @@ class AsyncCompletionsResource(AsyncAPIResource):
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> CompletionCreateResponse | AsyncStream[ChatCompletionChunk]:
-        return cast(
-            CompletionCreateResponse,
-            await self._post(
-                "/v5/chat/completions",
-                body=await async_maybe_transform(
-                    {
-                        "messages": messages,
-                        "model": model,
-                        "audio": audio,
-                        "frequency_penalty": frequency_penalty,
-                        "function_call": function_call,
-                        "functions": functions,
-                        "logit_bias": logit_bias,
-                        "logprobs": logprobs,
-                        "max_completion_tokens": max_completion_tokens,
-                        "max_tokens": max_tokens,
-                        "metadata": metadata,
-                        "modalities": modalities,
-                        "n": n,
-                        "parallel_tool_calls": parallel_tool_calls,
-                        "prediction": prediction,
-                        "presence_penalty": presence_penalty,
-                        "reasoning_effort": reasoning_effort,
-                        "response_format": response_format,
-                        "seed": seed,
-                        "stop": stop,
-                        "store": store,
-                        "stream": stream,
-                        "stream_options": stream_options,
-                        "temperature": temperature,
-                        "tool_choice": tool_choice,
-                        "tools": tools,
-                        "top_k": top_k,
-                        "top_logprobs": top_logprobs,
-                        "top_p": top_p,
-                    },
-                    completion_create_params.CompletionCreateParams,
-                ),
-                options=make_request_options(
-                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-                ),
-                cast_to=cast(
-                    Any, CompletionCreateResponse
-                ),  # Union types cannot be passed in as arguments in the type system
-                stream=stream or False,
-                stream_cls=AsyncStream[ChatCompletionChunk],
+        return await self._post(
+            "/v5/chat/completions",
+            body=await async_maybe_transform(
+                {
+                    "messages": messages,
+                    "model": model,
+                    "audio": audio,
+                    "frequency_penalty": frequency_penalty,
+                    "function_call": function_call,
+                    "functions": functions,
+                    "logit_bias": logit_bias,
+                    "logprobs": logprobs,
+                    "max_completion_tokens": max_completion_tokens,
+                    "max_tokens": max_tokens,
+                    "metadata": metadata,
+                    "modalities": modalities,
+                    "n": n,
+                    "parallel_tool_calls": parallel_tool_calls,
+                    "prediction": prediction,
+                    "presence_penalty": presence_penalty,
+                    "reasoning_effort": reasoning_effort,
+                    "response_format": response_format,
+                    "seed": seed,
+                    "stop": stop,
+                    "store": store,
+                    "stream": stream,
+                    "stream_options": stream_options,
+                    "temperature": temperature,
+                    "tool_choice": tool_choice,
+                    "tools": tools,
+                    "top_k": top_k,
+                    "top_logprobs": top_logprobs,
+                    "top_p": top_p,
+                },
+                completion_create_params.CompletionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
+            cast_to=cast(
+                Any, CompletionCreateResponse
+            ),  # Union types cannot be passed in as arguments in the type system
+            stream=stream or False,
+            stream_cls=AsyncStream[ChatCompletionChunk],
         )