together 1.5.34__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

together/resources/endpoints.py

@@ -1,599 +1,711 @@
-from __future__ import annotations
-
-from typing import Dict, List, Literal, Optional, Union
-
-from together.abstract import api_requestor
-from together.together_response import TogetherResponse
-from together.types import TogetherClient, TogetherRequest
-from together.types.endpoints import DedicatedEndpoint, HardwareWithStatus, ListEndpoint
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from __future__ import annotations
 
-class Endpoints:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
-
-    def list(
-        self,
-        type: Optional[Literal["dedicated", "serverless"]] = None,
-        usage_type: Optional[Literal["on-demand", "reserved"]] = None,
-        mine: Optional[bool] = None,
-    ) -> List[ListEndpoint]:
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import endpoint_list_params, endpoint_create_params, endpoint_update_params
+from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.autoscaling_param import AutoscalingParam
+from ..types.dedicated_endpoint import DedicatedEndpoint
+from ..types.endpoint_list_response import EndpointListResponse
+from ..types.endpoint_list_avzones_response import EndpointListAvzonesResponse
+
+__all__ = ["EndpointsResource", "AsyncEndpointsResource"]
+
+
+class EndpointsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> EndpointsResourceWithRawResponse:
         """
-        List all endpoints, can be filtered by endpoint type and ownership.
-
-        Args:
-            type (str, optional): Filter endpoints by endpoint type ("dedicated" or "serverless"). Defaults to None.
-            usage_type (str, optional): Filter endpoints by usage type ("on-demand" or "reserved"). Defaults to None.
-            mine (bool, optional): If True, return only endpoints owned by the caller. Defaults to None.
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
 
-        Returns:
-            List[ListEndpoint]: List of endpoint objects
+        For more information, see https://www.github.com/togethercomputer/together-py#accessing-raw-response-data-eg-headers
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        params: Dict[
-            str,
-            Union[
-                Literal["dedicated", "serverless"],
-                Literal["on-demand", "reserved"],
-                bool,
-            ],
-        ] = {}
-        if type is not None:
-            params["type"] = type
-        if usage_type is not None:
-            params["usage_type"] = usage_type
-        if mine is not None:
-            params["mine"] = mine
-
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="GET",
-                url="endpoints",
-                params=params,
-            ),
-            stream=False,
-        )
+        return EndpointsResourceWithRawResponse(self)
 
-        response.data = response.data["data"]
-
-        assert isinstance(response, TogetherResponse)
-        assert isinstance(response.data, list)
+    @cached_property
+    def with_streaming_response(self) -> EndpointsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        return [ListEndpoint(**endpoint) for endpoint in response.data]
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return EndpointsResourceWithStreamingResponse(self)
 
     def create(
         self,
         *,
-        model: str,
+        autoscaling: AutoscalingParam,
         hardware: str,
-        min_replicas: int,
-        max_replicas: int,
-        display_name: Optional[str] = None,
-        disable_prompt_cache: bool = True,
-        disable_speculative_decoding: bool = True,
-        state: Literal["STARTED", "STOPPED"] = "STARTED",
-        inactive_timeout: Optional[int] = None,
-        availability_zone: Optional[str] = None,
+        model: str,
+        availability_zone: str | Omit = omit,
+        disable_prompt_cache: bool | Omit = omit,
+        disable_speculative_decoding: bool | Omit = omit,
+        display_name: str | Omit = omit,
+        inactive_timeout: Optional[int] | Omit = omit,
+        state: Literal["STARTED", "STOPPED"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> DedicatedEndpoint:
-        """
-        Create a new dedicated endpoint.
+        """Creates a new dedicated endpoint for serving models.
+
+        The endpoint will
+        automatically start after creation. You can deploy any supported model on
+        hardware configurations that meet the model's requirements.
 
         Args:
-            model (str): The model to deploy on this endpoint
-            hardware (str): The hardware configuration to use for this endpoint
-            min_replicas (int): The minimum number of replicas to maintain
-            max_replicas (int): The maximum number of replicas to scale up to
-            display_name (str, optional): A human-readable name for the endpoint
-            disable_prompt_cache (bool, optional): Whether to disable the prompt cache. Defaults to False.
-            disable_speculative_decoding (bool, optional): Whether to disable speculative decoding. Defaults to False.
-            state (str, optional): The desired state of the endpoint. Defaults to "STARTED".
-            inactive_timeout (int, optional): The number of minutes of inactivity after which the endpoint will be automatically stopped. Set to 0 to disable automatic timeout.
-            availability_zone (str, optional): Start endpoint in specified availability zone (e.g., us-central-4b).
-
-        Returns:
-            DedicatedEndpoint: Object containing endpoint information
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        data: Dict[str, Union[str, bool, Dict[str, int], int]] = {
-            "model": model,
-            "hardware": hardware,
-            "autoscaling": {
-                "min_replicas": min_replicas,
-                "max_replicas": max_replicas,
-            },
-            "disable_prompt_cache": disable_prompt_cache,
-            "disable_speculative_decoding": disable_speculative_decoding,
-            "state": state,
-        }
-
-        if display_name is not None:
-            data["display_name"] = display_name
-
-        if inactive_timeout is not None:
-            data["inactive_timeout"] = inactive_timeout
-
-        if availability_zone is not None:
-            data["availability_zone"] = availability_zone
-
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="POST",
-                url="endpoints",
-                params=data,
-            ),
-            stream=False,
-        )
+          autoscaling: Configuration for automatic scaling of the endpoint
 
-        assert isinstance(response, TogetherResponse)
+          hardware: The hardware configuration to use for this endpoint
 
-        return DedicatedEndpoint(**response.data)
+          model: The model to deploy on this endpoint
 
-    def get(self, endpoint_id: str) -> DedicatedEndpoint:
-        """
-        Get details of a specific endpoint.
+          availability_zone: Create the endpoint in a specified availability zone (e.g., us-central-4b)
 
-        Args:
-            endpoint_id (str): ID of the endpoint to retrieve
+          disable_prompt_cache: Whether to disable the prompt cache for this endpoint
 
-        Returns:
-            DedicatedEndpoint: Object containing endpoint information
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+          disable_speculative_decoding: Whether to disable speculative decoding for this endpoint
 
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="GET",
-                url=f"endpoints/{endpoint_id}",
-            ),
-            stream=False,
-        )
+          display_name: A human-readable name for the endpoint
 
-        assert isinstance(response, TogetherResponse)
+          inactive_timeout: The number of minutes of inactivity after which the endpoint will be
+              automatically stopped. Set to null, omit or set to 0 to disable automatic
+              timeout.
 
-        return DedicatedEndpoint(**response.data)
+          state: The desired state of the endpoint
 
-    def delete(self, endpoint_id: str) -> None:
-        """
-        Delete a specific endpoint.
+          extra_headers: Send extra headers
 
-        Args:
-            endpoint_id (str): ID of the endpoint to delete
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+          extra_query: Add additional query parameters to the request
 
-        requestor.request(
-            options=TogetherRequest(
-                method="DELETE",
-                url=f"endpoints/{endpoint_id}",
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/endpoints",
+            body=maybe_transform(
+                {
+                    "autoscaling": autoscaling,
+                    "hardware": hardware,
+                    "model": model,
+                    "availability_zone": availability_zone,
+                    "disable_prompt_cache": disable_prompt_cache,
+                    "disable_speculative_decoding": disable_speculative_decoding,
+                    "display_name": display_name,
+                    "inactive_timeout": inactive_timeout,
+                    "state": state,
+                },
+                endpoint_create_params.EndpointCreateParams,
             ),
-            stream=False,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DedicatedEndpoint,
         )
 
-    def update(
+    def retrieve(
         self,
         endpoint_id: str,
         *,
-        min_replicas: Optional[int] = None,
-        max_replicas: Optional[int] = None,
-        state: Optional[Literal["STARTED", "STOPPED"]] = None,
-        display_name: Optional[str] = None,
-        inactive_timeout: Optional[int] = None,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> DedicatedEndpoint:
         """
-        Update an endpoint's configuration.
+        Retrieves details about a specific endpoint, including its current state,
+        configuration, and scaling settings.
 
         Args:
-            endpoint_id (str): ID of the endpoint to update
-            min_replicas (int, optional): The minimum number of replicas to maintain
-            max_replicas (int, optional): The maximum number of replicas to scale up to
-            state (str, optional): The desired state of the endpoint ("STARTED" or "STOPPED")
-            display_name (str, optional): A human-readable name for the endpoint
-            inactive_timeout (int, optional): The number of minutes of inactivity after which the endpoint will be automatically stopped. Set to 0 to disable automatic timeout.
-
-        Returns:
-            DedicatedEndpoint: Object containing endpoint information
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        data: Dict[str, Union[str, Dict[str, int], int]] = {}
-
-        if min_replicas is not None or max_replicas is not None:
-            current_min = min_replicas
-            current_max = max_replicas
-            if current_min is None or current_max is None:
-                # Get current values if only one is specified
-                current = self.get(endpoint_id=endpoint_id)
-                current_min = current_min or current.autoscaling.min_replicas
-                current_max = current_max or current.autoscaling.max_replicas
-            data["autoscaling"] = {
-                "min_replicas": current_min,
-                "max_replicas": current_max,
-            }
-
-        if state is not None:
-            data["state"] = state
-
-        if display_name is not None:
-            data["display_name"] = display_name
-
-        if inactive_timeout is not None:
-            data["inactive_timeout"] = inactive_timeout
-
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="PATCH",
-                url=f"endpoints/{endpoint_id}",
-                params=data,
+        if not endpoint_id:
+            raise ValueError(f"Expected a non-empty value for `endpoint_id` but received {endpoint_id!r}")
+        return self._get(
+            f"/endpoints/{endpoint_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=DedicatedEndpoint,
         )
 
-        assert isinstance(response, TogetherResponse)
-
-        return DedicatedEndpoint(**response.data)
+    def update(
+        self,
+        endpoint_id: str,
+        *,
+        autoscaling: AutoscalingParam | Omit = omit,
+        display_name: str | Omit = omit,
+        inactive_timeout: Optional[int] | Omit = omit,
+        state: Literal["STARTED", "STOPPED"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DedicatedEndpoint:
+        """Updates an existing endpoint's configuration.
 
-    def list_hardware(self, model: Optional[str] = None) -> List[HardwareWithStatus]:
-        """
-        List available hardware configurations.
+        You can modify the display name,
+        autoscaling settings, or change the endpoint's state (start/stop).
 
         Args:
-            model (str, optional): Filter hardware configurations by model compatibility. When provided,
-                                 the response includes availability status for each compatible configuration.
+          autoscaling: New autoscaling configuration for the endpoint
 
-        Returns:
-            List[HardwareWithStatus]: List of hardware configurations with their status
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+          display_name: A human-readable name for the endpoint
 
-        params = {}
-        if model is not None:
-            params["model"] = model
+          inactive_timeout: The number of minutes of inactivity after which the endpoint will be
+              automatically stopped. Set to 0 to disable automatic timeout.
 
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="GET",
-                url="hardware",
-                params=params,
-            ),
-            stream=False,
-        )
+          state: The desired state of the endpoint
 
-        assert isinstance(response, TogetherResponse)
-        assert isinstance(response.data, dict)
-        assert isinstance(response.data["data"], list)
+          extra_headers: Send extra headers
 
-        return [HardwareWithStatus(**item) for item in response.data["data"]]
+          extra_query: Add additional query parameters to the request
 
-    def list_avzones(self) -> List[str]:
-        """
-        List all available availability zones.
+          extra_body: Add additional JSON properties to the request
 
-        Returns:
-            List[str]: List of unique availability zones
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="GET",
-                url="clusters/availability-zones",
+        if not endpoint_id:
+            raise ValueError(f"Expected a non-empty value for `endpoint_id` but received {endpoint_id!r}")
+        return self._patch(
+            f"/endpoints/{endpoint_id}",
+            body=maybe_transform(
+                {
+                    "autoscaling": autoscaling,
+                    "display_name": display_name,
+                    "inactive_timeout": inactive_timeout,
+                    "state": state,
+                },
+                endpoint_update_params.EndpointUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=DedicatedEndpoint,
         )
 
-        assert isinstance(response, TogetherResponse)
-        assert isinstance(response.data, dict)
-        assert isinstance(response.data["avzones"], list)
+    def list(
+        self,
+        *,
+        mine: bool | Omit = omit,
+        type: Literal["dedicated", "serverless"] | Omit = omit,
+        usage_type: Literal["on-demand", "reserved"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EndpointListResponse:
+        """Returns a list of all endpoints associated with your account.
+
+        You can filter the
+        results by type (dedicated or serverless).
+
+        Args:
+          mine: If true, return only endpoints owned by the caller
+
+          type: Filter endpoints by type
 
-        return response.data["avzones"]
+          usage_type: Filter endpoints by usage type
 
+          extra_headers: Send extra headers
 
-class AsyncEndpoints:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
+          extra_query: Add additional query parameters to the request
 
-    async def list(
-        self,
-        type: Optional[Literal["dedicated", "serverless"]] = None,
-        usage_type: Optional[Literal["on-demand", "reserved"]] = None,
-        mine: Optional[bool] = None,
-    ) -> List[ListEndpoint]:
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        List all endpoints, can be filtered by type and ownership.
+        return self._get(
+            "/endpoints",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "mine": mine,
+                        "type": type,
+                        "usage_type": usage_type,
+                    },
+                    endpoint_list_params.EndpointListParams,
+                ),
+            ),
+            cast_to=EndpointListResponse,
+        )
+
+    def delete(
+        self,
+        endpoint_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """Permanently deletes an endpoint.
+
+        This action cannot be undone.
 
         Args:
-            type (str, optional): Filter endpoints by type ("dedicated" or "serverless"). Defaults to None.
-            usage_type (str, optional): Filter endpoints by usage type ("on-demand" or "reserved"). Defaults to None.
-            mine (bool, optional): If True, return only endpoints owned by the caller. Defaults to None.
+          extra_headers: Send extra headers
 
-        Returns:
-            List[ListEndpoint]: List of endpoint objects
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        params: Dict[
-            str,
-            Union[
-                Literal["dedicated", "serverless"],
-                Literal["on-demand", "reserved"],
-                bool,
-            ],
-        ] = {}
-        if type is not None:
-            params["type"] = type
-        if usage_type is not None:
-            params["usage_type"] = usage_type
-        if mine is not None:
-            params["mine"] = mine
-
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="GET",
-                url="endpoints",
-                params=params,
+        if not endpoint_id:
+            raise ValueError(f"Expected a non-empty value for `endpoint_id` but received {endpoint_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/endpoints/{endpoint_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=NoneType,
         )
 
-        assert isinstance(response, TogetherResponse)
-        assert isinstance(response.data, list)
+    def list_avzones(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EndpointListAvzonesResponse:
+        """List all available availability zones."""
+        return self._get(
+            "/clusters/availability-zones",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=EndpointListAvzonesResponse,
+        )
+
+
+class AsyncEndpointsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncEndpointsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEndpointsResourceWithRawResponse(self)
 
-        return [ListEndpoint(**endpoint) for endpoint in response.data]
+    @cached_property
+    def with_streaming_response(self) -> AsyncEndpointsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return AsyncEndpointsResourceWithStreamingResponse(self)
 
     async def create(
         self,
         *,
-        model: str,
+        autoscaling: AutoscalingParam,
         hardware: str,
-        min_replicas: int,
-        max_replicas: int,
-        display_name: Optional[str] = None,
-        disable_prompt_cache: bool = True,
-        disable_speculative_decoding: bool = True,
-        state: Literal["STARTED", "STOPPED"] = "STARTED",
-        inactive_timeout: Optional[int] = None,
-        availability_zone: Optional[str] = None,
+        model: str,
+        availability_zone: str | Omit = omit,
+        disable_prompt_cache: bool | Omit = omit,
+        disable_speculative_decoding: bool | Omit = omit,
+        display_name: str | Omit = omit,
+        inactive_timeout: Optional[int] | Omit = omit,
+        state: Literal["STARTED", "STOPPED"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> DedicatedEndpoint:
-        """
-        Create a new dedicated endpoint.
+        """Creates a new dedicated endpoint for serving models.
+
+        The endpoint will
+        automatically start after creation. You can deploy any supported model on
+        hardware configurations that meet the model's requirements.
 
         Args:
-            model (str): The model to deploy on this endpoint
-            hardware (str): The hardware configuration to use for this endpoint
-            min_replicas (int): The minimum number of replicas to maintain
-            max_replicas (int): The maximum number of replicas to scale up to
-            display_name (str, optional): A human-readable name for the endpoint
-            disable_prompt_cache (bool, optional): Whether to disable the prompt cache. Defaults to False.
-            disable_speculative_decoding (bool, optional): Whether to disable speculative decoding. Defaults to False.
-            state (str, optional): The desired state of the endpoint. Defaults to "STARTED".
-            inactive_timeout (int, optional): The number of minutes of inactivity after which the endpoint will be automatically stopped. Set to 0 to disable automatic timeout.
-
-        Returns:
-            DedicatedEndpoint: Object containing endpoint information
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        data: Dict[str, Union[str, bool, Dict[str, int], int]] = {
-            "model": model,
-            "hardware": hardware,
-            "autoscaling": {
-                "min_replicas": min_replicas,
-                "max_replicas": max_replicas,
-            },
-            "disable_prompt_cache": disable_prompt_cache,
-            "disable_speculative_decoding": disable_speculative_decoding,
-            "state": state,
-        }
-
-        if display_name is not None:
-            data["display_name"] = display_name
-
-        if inactive_timeout is not None:
-            data["inactive_timeout"] = inactive_timeout
-
-        if availability_zone is not None:
-            data["availability_zone"] = availability_zone
-
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="POST",
-                url="endpoints",
-                params=data,
-            ),
-            stream=False,
-        )
+          autoscaling: Configuration for automatic scaling of the endpoint
 
-        assert isinstance(response, TogetherResponse)
+          hardware: The hardware configuration to use for this endpoint
 
-        return DedicatedEndpoint(**response.data)
+          model: The model to deploy on this endpoint
 
-    async def get(self, endpoint_id: str) -> DedicatedEndpoint:
-        """
-        Get details of a specific endpoint.
+          availability_zone: Create the endpoint in a specified availability zone (e.g., us-central-4b)
 
-        Args:
-            endpoint_id (str): ID of the endpoint to retrieve
+          disable_prompt_cache: Whether to disable the prompt cache for this endpoint
 
-        Returns:
-            DedicatedEndpoint: Object containing endpoint information
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+          disable_speculative_decoding: Whether to disable speculative decoding for this endpoint
 
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="GET",
-                url=f"endpoints/{endpoint_id}",
-            ),
-            stream=False,
-        )
+          display_name: A human-readable name for the endpoint
 
-        assert isinstance(response, TogetherResponse)
+          inactive_timeout: The number of minutes of inactivity after which the endpoint will be
+              automatically stopped. Set to null, omit or set to 0 to disable automatic
+              timeout.
 
-        return DedicatedEndpoint(**response.data)
+          state: The desired state of the endpoint
 
-    async def delete(self, endpoint_id: str) -> None:
-        """
-        Delete a specific endpoint.
+          extra_headers: Send extra headers
 
-        Args:
-            endpoint_id (str): ID of the endpoint to delete
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+        return await self._post(
+            "/endpoints",
+            body=await async_maybe_transform(
+                {
+                    "autoscaling": autoscaling,
+                    "hardware": hardware,
+                    "model": model,
+                    "availability_zone": availability_zone,
+                    "disable_prompt_cache": disable_prompt_cache,
+                    "disable_speculative_decoding": disable_speculative_decoding,
+                    "display_name": display_name,
+                    "inactive_timeout": inactive_timeout,
+                    "state": state,
+                },
+                endpoint_create_params.EndpointCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DedicatedEndpoint,
         )
 
-        await requestor.arequest(
-            options=TogetherRequest(
-                method="DELETE",
-                url=f"endpoints/{endpoint_id}",
+    async def retrieve(
+        self,
+        endpoint_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> DedicatedEndpoint:
+        """
+        Retrieves details about a specific endpoint, including its current state,
+        configuration, and scaling settings.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not endpoint_id:
+            raise ValueError(f"Expected a non-empty value for `endpoint_id` but received {endpoint_id!r}")
+        return await self._get(
+            f"/endpoints/{endpoint_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=DedicatedEndpoint,
         )
 
     async def update(
         self,
         endpoint_id: str,
         *,
-        min_replicas: Optional[int] = None,
-        max_replicas: Optional[int] = None,
-        state: Optional[Literal["STARTED", "STOPPED"]] = None,
-        display_name: Optional[str] = None,
-        inactive_timeout: Optional[int] = None,
+        autoscaling: AutoscalingParam | Omit = omit,
+        display_name: str | Omit = omit,
+        inactive_timeout: Optional[int] | Omit = omit,
+        state: Literal["STARTED", "STOPPED"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
     ) -> DedicatedEndpoint:
-        """
-        Update an endpoint's configuration.
+        """Updates an existing endpoint's configuration.
+
+        You can modify the display name,
+        autoscaling settings, or change the endpoint's state (start/stop).
 
         Args:
-            endpoint_id (str): ID of the endpoint to update
-            min_replicas (int, optional): The minimum number of replicas to maintain
-            max_replicas (int, optional): The maximum number of replicas to scale up to
-            state (str, optional): The desired state of the endpoint ("STARTED" or "STOPPED")
-            display_name (str, optional): A human-readable name for the endpoint
-            inactive_timeout (int, optional): The number of minutes of inactivity after which the endpoint will be automatically stopped. Set to 0 to disable automatic timeout.
-
-        Returns:
-            DedicatedEndpoint: Object containing endpoint information
+          autoscaling: New autoscaling configuration for the endpoint
+
+          display_name: A human-readable name for the endpoint
+
+          inactive_timeout: The number of minutes of inactivity after which the endpoint will be
+              automatically stopped. Set to 0 to disable automatic timeout.
+
+          state: The desired state of the endpoint
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        data: Dict[str, Union[str, Dict[str, int], int]] = {}
-
-        if min_replicas is not None or max_replicas is not None:
-            current_min = min_replicas
-            current_max = max_replicas
-            if current_min is None or current_max is None:
-                # Get current values if only one is specified
-                current = await self.get(endpoint_id=endpoint_id)
-                current_min = current_min or current.autoscaling.min_replicas
-                current_max = current_max or current.autoscaling.max_replicas
-            data["autoscaling"] = {
-                "min_replicas": current_min,
-                "max_replicas": current_max,
-            }
-
-        if state is not None:
-            data["state"] = state
-
-        if display_name is not None:
-            data["display_name"] = display_name
-
-        if inactive_timeout is not None:
-            data["inactive_timeout"] = inactive_timeout
-
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="PATCH",
-                url=f"endpoints/{endpoint_id}",
-                params=data,
+        if not endpoint_id:
+            raise ValueError(f"Expected a non-empty value for `endpoint_id` but received {endpoint_id!r}")
+        return await self._patch(
+            f"/endpoints/{endpoint_id}",
+            body=await async_maybe_transform(
+                {
+                    "autoscaling": autoscaling,
+                    "display_name": display_name,
+                    "inactive_timeout": inactive_timeout,
+                    "state": state,
+                },
+                endpoint_update_params.EndpointUpdateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=DedicatedEndpoint,
         )
 
-        assert isinstance(response, TogetherResponse)
+    async def list(
+        self,
+        *,
+        mine: bool | Omit = omit,
+        type: Literal["dedicated", "serverless"] | Omit = omit,
+        usage_type: Literal["on-demand", "reserved"] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EndpointListResponse:
+        """Returns a list of all endpoints associated with your account.
+
+        You can filter the
+        results by type (dedicated or serverless).
+
+        Args:
+          mine: If true, return only endpoints owned by the caller
+
+          type: Filter endpoints by type
+
+          usage_type: Filter endpoints by usage type
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
 
-        return DedicatedEndpoint(**response.data)
+          extra_body: Add additional JSON properties to the request
 
-    async def list_hardware(
-        self, model: Optional[str] = None
-    ) -> List[HardwareWithStatus]:
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        List available hardware configurations.
+        return await self._get(
+            "/endpoints",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "mine": mine,
+                        "type": type,
+                        "usage_type": usage_type,
+                    },
+                    endpoint_list_params.EndpointListParams,
+                ),
+            ),
+            cast_to=EndpointListResponse,
+        )
+
+    async def delete(
+        self,
+        endpoint_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> None:
+        """Permanently deletes an endpoint.
+
+        This action cannot be undone.
 
         Args:
-            model (str, optional): Filter hardware configurations by model compatibility. When provided,
-                                 the response includes availability status for each compatible configuration.
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
 
-        Returns:
-            List[HardwareWithStatus]: List of hardware configurations with their status
+          timeout: Override the client-level default timeout for this request, in seconds
         """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+        if not endpoint_id:
+            raise ValueError(f"Expected a non-empty value for `endpoint_id` but received {endpoint_id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/endpoints/{endpoint_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
         )
 
-        params = {}
-        if model is not None:
-            params["model"] = model
-
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="GET",
-                url="hardware",
-                params=params,
+    async def list_avzones(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> EndpointListAvzonesResponse:
+        """List all available availability zones."""
+        return await self._get(
+            "/clusters/availability-zones",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=EndpointListAvzonesResponse,
         )
 
-        assert isinstance(response, TogetherResponse)
-        assert isinstance(response.data, dict)
-        assert isinstance(response.data["data"], list)
 
-        return [HardwareWithStatus(**item) for item in response.data["data"]]
+class EndpointsResourceWithRawResponse:
+    def __init__(self, endpoints: EndpointsResource) -> None:
+        self._endpoints = endpoints
 
-    async def list_avzones(self) -> List[str]:
-        """
-        List all availability zones.
+        self.create = to_raw_response_wrapper(
+            endpoints.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            endpoints.retrieve,
+        )
+        self.update = to_raw_response_wrapper(
+            endpoints.update,
+        )
+        self.list = to_raw_response_wrapper(
+            endpoints.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            endpoints.delete,
+        )
+        self.list_avzones = to_raw_response_wrapper(
+            endpoints.list_avzones,
+        )
 
-        Returns:
-            List[str]: List of unique availability zones
-        """
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+
+class AsyncEndpointsResourceWithRawResponse:
+    def __init__(self, endpoints: AsyncEndpointsResource) -> None:
+        self._endpoints = endpoints
+
+        self.create = async_to_raw_response_wrapper(
+            endpoints.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            endpoints.retrieve,
+        )
+        self.update = async_to_raw_response_wrapper(
+            endpoints.update,
+        )
+        self.list = async_to_raw_response_wrapper(
+            endpoints.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            endpoints.delete,
+        )
+        self.list_avzones = async_to_raw_response_wrapper(
+            endpoints.list_avzones,
         )
 
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="GET",
-                url="clusters/availability-zones",
-            ),
-            stream=False,
+
+class EndpointsResourceWithStreamingResponse:
+    def __init__(self, endpoints: EndpointsResource) -> None:
+        self._endpoints = endpoints
+
+        self.create = to_streamed_response_wrapper(
+            endpoints.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            endpoints.retrieve,
+        )
+        self.update = to_streamed_response_wrapper(
+            endpoints.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            endpoints.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            endpoints.delete,
+        )
+        self.list_avzones = to_streamed_response_wrapper(
+            endpoints.list_avzones,
         )
 
-        assert isinstance(response, TogetherResponse)
-        assert isinstance(response.data, dict)
-        assert isinstance(response.data["avzones"], list)
 
-        return response.data["avzones"]
+class AsyncEndpointsResourceWithStreamingResponse:
+    def __init__(self, endpoints: AsyncEndpointsResource) -> None:
+        self._endpoints = endpoints
+
+        self.create = async_to_streamed_response_wrapper(
+            endpoints.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            endpoints.retrieve,
+        )
+        self.update = async_to_streamed_response_wrapper(
+            endpoints.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            endpoints.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            endpoints.delete,
+        )
+        self.list_avzones = async_to_streamed_response_wrapper(
+            endpoints.list_avzones,
+        )