c63a5cfe-b235-4fbe-8bbb-82a9e02a482a-python 0.1.0a3__py3-none-any.whl → 0.1.0a5__py3-none-any.whl

digitalocean_genai_sdk/resources/api_keys/api_keys.py

@@ -1,275 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import List
-from typing_extensions import Literal
-
-import httpx
-
-from . import api_keys_ as api_keys
-from ...types import api_key_list_params
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-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.api_key_list_response import APIKeyListResponse
-
-__all__ = ["APIKeysResource", "AsyncAPIKeysResource"]
-
-
-class APIKeysResource(SyncAPIResource):
-    @cached_property
-    def api_keys(self) -> api_keys.APIKeysResource:
-        return api_keys.APIKeysResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> APIKeysResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return APIKeysResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> APIKeysResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return APIKeysResourceWithStreamingResponse(self)
-
-    def list(
-        self,
-        *,
-        page: int | NotGiven = NOT_GIVEN,
-        per_page: int | NotGiven = NOT_GIVEN,
-        public_only: bool | NotGiven = NOT_GIVEN,
-        usecases: List[
-            Literal[
-                "MODEL_USECASE_UNKNOWN",
-                "MODEL_USECASE_AGENT",
-                "MODEL_USECASE_FINETUNED",
-                "MODEL_USECASE_KNOWLEDGEBASE",
-                "MODEL_USECASE_GUARDRAIL",
-                "MODEL_USECASE_REASONING",
-                "MODEL_USECASE_SERVERLESS",
-            ]
-        ]
-        | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> APIKeyListResponse:
-        """
-        To list all models, send a GET request to `/v2/gen-ai/models`.
-
-        Args:
-          page: page number.
-
-          per_page: items per page.
-
-          public_only: only include models that are publicly available.
-
-          usecases: include only models defined for the listed usecases.
-
-              - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
-              - MODEL_USECASE_AGENT: The model maybe used in an agent
-              - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
-              - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
-                (embedding models)
-              - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
-              - MODEL_USECASE_REASONING: The model usecase for reasoning
-              - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
-
-          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
-        """
-        return self._get(
-            "/v2/genai/models",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "page": page,
-                        "per_page": per_page,
-                        "public_only": public_only,
-                        "usecases": usecases,
-                    },
-                    api_key_list_params.APIKeyListParams,
-                ),
-            ),
-            cast_to=APIKeyListResponse,
-        )
-
-
-class AsyncAPIKeysResource(AsyncAPIResource):
-    @cached_property
-    def api_keys(self) -> api_keys.AsyncAPIKeysResource:
-        return api_keys.AsyncAPIKeysResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncAPIKeysResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncAPIKeysResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncAPIKeysResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncAPIKeysResourceWithStreamingResponse(self)
-
-    async def list(
-        self,
-        *,
-        page: int | NotGiven = NOT_GIVEN,
-        per_page: int | NotGiven = NOT_GIVEN,
-        public_only: bool | NotGiven = NOT_GIVEN,
-        usecases: List[
-            Literal[
-                "MODEL_USECASE_UNKNOWN",
-                "MODEL_USECASE_AGENT",
-                "MODEL_USECASE_FINETUNED",
-                "MODEL_USECASE_KNOWLEDGEBASE",
-                "MODEL_USECASE_GUARDRAIL",
-                "MODEL_USECASE_REASONING",
-                "MODEL_USECASE_SERVERLESS",
-            ]
-        ]
-        | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> APIKeyListResponse:
-        """
-        To list all models, send a GET request to `/v2/gen-ai/models`.
-
-        Args:
-          page: page number.
-
-          per_page: items per page.
-
-          public_only: only include models that are publicly available.
-
-          usecases: include only models defined for the listed usecases.
-
-              - MODEL_USECASE_UNKNOWN: The use case of the model is unknown
-              - MODEL_USECASE_AGENT: The model maybe used in an agent
-              - MODEL_USECASE_FINETUNED: The model maybe used for fine tuning
-              - MODEL_USECASE_KNOWLEDGEBASE: The model maybe used for knowledge bases
-                (embedding models)
-              - MODEL_USECASE_GUARDRAIL: The model maybe used for guardrails
-              - MODEL_USECASE_REASONING: The model usecase for reasoning
-              - MODEL_USECASE_SERVERLESS: The model usecase for serverless inference
-
-          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
-        """
-        return await self._get(
-            "/v2/genai/models",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=await async_maybe_transform(
-                    {
-                        "page": page,
-                        "per_page": per_page,
-                        "public_only": public_only,
-                        "usecases": usecases,
-                    },
-                    api_key_list_params.APIKeyListParams,
-                ),
-            ),
-            cast_to=APIKeyListResponse,
-        )
-
-
-class APIKeysResourceWithRawResponse:
-    def __init__(self, api_keys: APIKeysResource) -> None:
-        self._api_keys = api_keys
-
-        self.list = to_raw_response_wrapper(
-            api_keys.list,
-        )
-
-    @cached_property
-    def api_keys(self) -> api_keys.APIKeysResourceWithRawResponse:
-        return api_keys.APIKeysResourceWithRawResponse(self._api_keys.api_keys)
-
-
-class AsyncAPIKeysResourceWithRawResponse:
-    def __init__(self, api_keys: AsyncAPIKeysResource) -> None:
-        self._api_keys = api_keys
-
-        self.list = async_to_raw_response_wrapper(
-            api_keys.list,
-        )
-
-    @cached_property
-    def api_keys(self) -> api_keys.AsyncAPIKeysResourceWithRawResponse:
-        return api_keys.AsyncAPIKeysResourceWithRawResponse(self._api_keys.api_keys)
-
-
-class APIKeysResourceWithStreamingResponse:
-    def __init__(self, api_keys: APIKeysResource) -> None:
-        self._api_keys = api_keys
-
-        self.list = to_streamed_response_wrapper(
-            api_keys.list,
-        )
-
-    @cached_property
-    def api_keys(self) -> api_keys.APIKeysResourceWithStreamingResponse:
-        return api_keys.APIKeysResourceWithStreamingResponse(self._api_keys.api_keys)
-
-
-class AsyncAPIKeysResourceWithStreamingResponse:
-    def __init__(self, api_keys: AsyncAPIKeysResource) -> None:
-        self._api_keys = api_keys
-
-        self.list = async_to_streamed_response_wrapper(
-            api_keys.list,
-        )
-
-    @cached_property
-    def api_keys(self) -> api_keys.AsyncAPIKeysResourceWithStreamingResponse:
-        return api_keys.AsyncAPIKeysResourceWithStreamingResponse(self._api_keys.api_keys)

digitalocean_genai_sdk/resources/auth/__init__.py

@@ -1,33 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from .auth import (
-    AuthResource,
-    AsyncAuthResource,
-    AuthResourceWithRawResponse,
-    AsyncAuthResourceWithRawResponse,
-    AuthResourceWithStreamingResponse,
-    AsyncAuthResourceWithStreamingResponse,
-)
-from .agents import (
-    AgentsResource,
-    AsyncAgentsResource,
-    AgentsResourceWithRawResponse,
-    AsyncAgentsResourceWithRawResponse,
-    AgentsResourceWithStreamingResponse,
-    AsyncAgentsResourceWithStreamingResponse,
-)
-
-__all__ = [
-    "AgentsResource",
-    "AsyncAgentsResource",
-    "AgentsResourceWithRawResponse",
-    "AsyncAgentsResourceWithRawResponse",
-    "AgentsResourceWithStreamingResponse",
-    "AsyncAgentsResourceWithStreamingResponse",
-    "AuthResource",
-    "AsyncAuthResource",
-    "AuthResourceWithRawResponse",
-    "AsyncAuthResourceWithRawResponse",
-    "AuthResourceWithStreamingResponse",
-    "AsyncAuthResourceWithStreamingResponse",
-]

digitalocean_genai_sdk/resources/auth/agents/agents.py

@@ -1,102 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from .token import (
-    TokenResource,
-    AsyncTokenResource,
-    TokenResourceWithRawResponse,
-    AsyncTokenResourceWithRawResponse,
-    TokenResourceWithStreamingResponse,
-    AsyncTokenResourceWithStreamingResponse,
-)
-from ...._compat import cached_property
-from ...._resource import SyncAPIResource, AsyncAPIResource
-
-__all__ = ["AgentsResource", "AsyncAgentsResource"]
-
-
-class AgentsResource(SyncAPIResource):
-    @cached_property
-    def token(self) -> TokenResource:
-        return TokenResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AgentsResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AgentsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AgentsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AgentsResourceWithStreamingResponse(self)
-
-
-class AsyncAgentsResource(AsyncAPIResource):
-    @cached_property
-    def token(self) -> AsyncTokenResource:
-        return AsyncTokenResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncAgentsResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncAgentsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncAgentsResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncAgentsResourceWithStreamingResponse(self)
-
-
-class AgentsResourceWithRawResponse:
-    def __init__(self, agents: AgentsResource) -> None:
-        self._agents = agents
-
-    @cached_property
-    def token(self) -> TokenResourceWithRawResponse:
-        return TokenResourceWithRawResponse(self._agents.token)
-
-
-class AsyncAgentsResourceWithRawResponse:
-    def __init__(self, agents: AsyncAgentsResource) -> None:
-        self._agents = agents
-
-    @cached_property
-    def token(self) -> AsyncTokenResourceWithRawResponse:
-        return AsyncTokenResourceWithRawResponse(self._agents.token)
-
-
-class AgentsResourceWithStreamingResponse:
-    def __init__(self, agents: AgentsResource) -> None:
-        self._agents = agents
-
-    @cached_property
-    def token(self) -> TokenResourceWithStreamingResponse:
-        return TokenResourceWithStreamingResponse(self._agents.token)
-
-
-class AsyncAgentsResourceWithStreamingResponse:
-    def __init__(self, agents: AsyncAgentsResource) -> None:
-        self._agents = agents
-
-    @cached_property
-    def token(self) -> AsyncTokenResourceWithStreamingResponse:
-        return AsyncTokenResourceWithStreamingResponse(self._agents.token)

digitalocean_genai_sdk/resources/auth/agents/token.py

@@ -1,173 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import httpx
-
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-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.auth.agents import token_create_params
-from ....types.auth.agents.token_create_response import TokenCreateResponse
-
-__all__ = ["TokenResource", "AsyncTokenResource"]
-
-
-class TokenResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> TokenResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return TokenResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> TokenResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return TokenResourceWithStreamingResponse(self)
-
-    def create(
-        self,
-        path_agent_uuid: str,
-        *,
-        body_agent_uuid: str | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> TokenCreateResponse:
-        """
-        To issue an agent token, send a POST request to
-        `/v2/gen-ai/auth/agents/{agent_uuid}/token`.
-
-        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 path_agent_uuid:
-            raise ValueError(f"Expected a non-empty value for `path_agent_uuid` but received {path_agent_uuid!r}")
-        return self._post(
-            f"/v2/genai/auth/agents/{path_agent_uuid}/token",
-            body=maybe_transform({"body_agent_uuid": body_agent_uuid}, token_create_params.TokenCreateParams),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=TokenCreateResponse,
-        )
-
-
-class AsyncTokenResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncTokenResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncTokenResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncTokenResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncTokenResourceWithStreamingResponse(self)
-
-    async def create(
-        self,
-        path_agent_uuid: str,
-        *,
-        body_agent_uuid: str | NotGiven = NOT_GIVEN,
-        # 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,
-    ) -> TokenCreateResponse:
-        """
-        To issue an agent token, send a POST request to
-        `/v2/gen-ai/auth/agents/{agent_uuid}/token`.
-
-        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 path_agent_uuid:
-            raise ValueError(f"Expected a non-empty value for `path_agent_uuid` but received {path_agent_uuid!r}")
-        return await self._post(
-            f"/v2/genai/auth/agents/{path_agent_uuid}/token",
-            body=await async_maybe_transform(
-                {"body_agent_uuid": body_agent_uuid}, token_create_params.TokenCreateParams
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=TokenCreateResponse,
-        )
-
-
-class TokenResourceWithRawResponse:
-    def __init__(self, token: TokenResource) -> None:
-        self._token = token
-
-        self.create = to_raw_response_wrapper(
-            token.create,
-        )
-
-
-class AsyncTokenResourceWithRawResponse:
-    def __init__(self, token: AsyncTokenResource) -> None:
-        self._token = token
-
-        self.create = async_to_raw_response_wrapper(
-            token.create,
-        )
-
-
-class TokenResourceWithStreamingResponse:
-    def __init__(self, token: TokenResource) -> None:
-        self._token = token
-
-        self.create = to_streamed_response_wrapper(
-            token.create,
-        )
-
-
-class AsyncTokenResourceWithStreamingResponse:
-    def __init__(self, token: AsyncTokenResource) -> None:
-        self._token = token
-
-        self.create = async_to_streamed_response_wrapper(
-            token.create,
-        )

digitalocean_genai_sdk/resources/auth/auth.py

@@ -1,102 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-from .agents.agents import (
-    AgentsResource,
-    AsyncAgentsResource,
-    AgentsResourceWithRawResponse,
-    AsyncAgentsResourceWithRawResponse,
-    AgentsResourceWithStreamingResponse,
-    AsyncAgentsResourceWithStreamingResponse,
-)
-
-__all__ = ["AuthResource", "AsyncAuthResource"]
-
-
-class AuthResource(SyncAPIResource):
-    @cached_property
-    def agents(self) -> AgentsResource:
-        return AgentsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AuthResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AuthResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AuthResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AuthResourceWithStreamingResponse(self)
-
-
-class AsyncAuthResource(AsyncAPIResource):
-    @cached_property
-    def agents(self) -> AsyncAgentsResource:
-        return AsyncAgentsResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncAuthResourceWithRawResponse:
-        """
-        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/digitalocean/genai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncAuthResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncAuthResourceWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/digitalocean/genai-python#with_streaming_response
-        """
-        return AsyncAuthResourceWithStreamingResponse(self)
-
-
-class AuthResourceWithRawResponse:
-    def __init__(self, auth: AuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AgentsResourceWithRawResponse:
-        return AgentsResourceWithRawResponse(self._auth.agents)
-
-
-class AsyncAuthResourceWithRawResponse:
-    def __init__(self, auth: AsyncAuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AsyncAgentsResourceWithRawResponse:
-        return AsyncAgentsResourceWithRawResponse(self._auth.agents)
-
-
-class AuthResourceWithStreamingResponse:
-    def __init__(self, auth: AuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AgentsResourceWithStreamingResponse:
-        return AgentsResourceWithStreamingResponse(self._auth.agents)
-
-
-class AsyncAuthResourceWithStreamingResponse:
-    def __init__(self, auth: AsyncAuthResource) -> None:
-        self._auth = auth
-
-    @cached_property
-    def agents(self) -> AsyncAgentsResourceWithStreamingResponse:
-        return AsyncAgentsResourceWithStreamingResponse(self._auth.agents)