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

{gradientai → do_gradientai}/_client.py

@@ -13,6 +13,7 @@ from ._qs import Querystring
 from ._types import (
     NOT_GIVEN,
     Omit,
+    Headers,
     Timeout,
     NotGiven,
     Transport,
@@ -23,7 +24,7 @@ from ._utils import is_given, get_async_library
 from ._compat import cached_property
 from ._version import __version__
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
-from ._exceptions import APIStatusError, GradientAIError
+from ._exceptions import APIStatusError
 from ._base_client import (
     DEFAULT_MAX_RETRIES,
     SyncAPIClient,
@@ -31,15 +32,14 @@ from ._base_client import (
 )
 
 if TYPE_CHECKING:
-    from .resources import chat, agents, models, regions, inference, providers, indexing_jobs, knowledge_bases
+    from .resources import chat, agents, models, regions, inference, knowledge_bases, model_providers
     from .resources.models import ModelsResource, AsyncModelsResource
+    from .resources.regions import RegionsResource, AsyncRegionsResource
     from .resources.chat.chat import ChatResource, AsyncChatResource
     from .resources.agents.agents import AgentsResource, AsyncAgentsResource
-    from .resources.indexing_jobs import IndexingJobsResource, AsyncIndexingJobsResource
-    from .resources.regions.regions import RegionsResource, AsyncRegionsResource
     from .resources.inference.inference import InferenceResource, AsyncInferenceResource
-    from .resources.providers.providers import ProvidersResource, AsyncProvidersResource
     from .resources.knowledge_bases.knowledge_bases import KnowledgeBasesResource, AsyncKnowledgeBasesResource
+    from .resources.model_providers.model_providers import ModelProvidersResource, AsyncModelProvidersResource
 
 __all__ = [
     "Timeout",
@@ -55,12 +55,14 @@ __all__ = [
 
 class GradientAI(SyncAPIClient):
     # client options
-    api_key: str
+    api_key: str | None
+    inference_key: str | None
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
+        inference_key: str | None = None,
         base_url: str | httpx.URL | None = None,
         timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -82,16 +84,18 @@ class GradientAI(SyncAPIClient):
     ) -> None:
         """Construct a new synchronous GradientAI client instance.
 
-        This automatically infers the `api_key` argument from the `GRADIENTAI_API_KEY` environment variable if it is not provided.
+        This automatically infers the following arguments from their corresponding environment variables if they are not provided:
+        - `api_key` from `GRADIENTAI_API_KEY`
+        - `inference_key` from `GRADIENTAI_INFERENCE_KEY`
         """
         if api_key is None:
             api_key = os.environ.get("GRADIENTAI_API_KEY")
-        if api_key is None:
-            raise GradientAIError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the GRADIENTAI_API_KEY environment variable"
-            )
         self.api_key = api_key
 
+        if inference_key is None:
+            inference_key = os.environ.get("GRADIENTAI_INFERENCE_KEY")
+        self.inference_key = inference_key
+
         if base_url is None:
             base_url = os.environ.get("GRADIENT_AI_BASE_URL")
         self._base_url_overridden = base_url is not None
@@ -116,10 +120,10 @@ class GradientAI(SyncAPIClient):
         return AgentsResource(self)
 
     @cached_property
-    def providers(self) -> ProvidersResource:
-        from .resources.providers import ProvidersResource
+    def model_providers(self) -> ModelProvidersResource:
+        from .resources.model_providers import ModelProvidersResource
 
-        return ProvidersResource(self)
+        return ModelProvidersResource(self)
 
     @cached_property
     def regions(self) -> RegionsResource:
@@ -127,12 +131,6 @@ class GradientAI(SyncAPIClient):
 
         return RegionsResource(self)
 
-    @cached_property
-    def indexing_jobs(self) -> IndexingJobsResource:
-        from .resources.indexing_jobs import IndexingJobsResource
-
-        return IndexingJobsResource(self)
-
     @cached_property
     def knowledge_bases(self) -> KnowledgeBasesResource:
         from .resources.knowledge_bases import KnowledgeBasesResource
@@ -174,6 +172,8 @@ class GradientAI(SyncAPIClient):
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
+        if api_key is None:
+            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -185,10 +185,22 @@ class GradientAI(SyncAPIClient):
             **self._custom_headers,
         }
 
+    @override
+    def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if self.api_key and headers.get("Authorization"):
+            return
+        if isinstance(custom_headers.get("Authorization"), Omit):
+            return
+
+        raise TypeError(
+            '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"'
+        )
+
     def copy(
         self,
         *,
         api_key: str | None = None,
+        inference_key: str | None = None,
         base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         http_client: httpx.Client | None = None,
@@ -223,6 +235,7 @@ class GradientAI(SyncAPIClient):
         http_client = http_client or self._client
         client = self.__class__(
             api_key=api_key or self.api_key,
+            inference_key=inference_key or self.inference_key,
             base_url=base_url or self.base_url,
             timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
             http_client=http_client,
@@ -274,12 +287,14 @@ class GradientAI(SyncAPIClient):
 
 class AsyncGradientAI(AsyncAPIClient):
     # client options
-    api_key: str
+    api_key: str | None
+    inference_key: str | None
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
+        inference_key: str | None = None,
         base_url: str | httpx.URL | None = None,
         timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -301,16 +316,18 @@ class AsyncGradientAI(AsyncAPIClient):
     ) -> None:
         """Construct a new async AsyncGradientAI client instance.
 
-        This automatically infers the `api_key` argument from the `GRADIENTAI_API_KEY` environment variable if it is not provided.
+        This automatically infers the following arguments from their corresponding environment variables if they are not provided:
+        - `api_key` from `GRADIENTAI_API_KEY`
+        - `inference_key` from `GRADIENTAI_INFERENCE_KEY`
         """
         if api_key is None:
             api_key = os.environ.get("GRADIENTAI_API_KEY")
-        if api_key is None:
-            raise GradientAIError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the GRADIENTAI_API_KEY environment variable"
-            )
         self.api_key = api_key
 
+        if inference_key is None:
+            inference_key = os.environ.get("GRADIENTAI_INFERENCE_KEY")
+        self.inference_key = inference_key
+
         if base_url is None:
             base_url = os.environ.get("GRADIENT_AI_BASE_URL")
         self._base_url_overridden = base_url is not None
@@ -335,10 +352,10 @@ class AsyncGradientAI(AsyncAPIClient):
         return AsyncAgentsResource(self)
 
     @cached_property
-    def providers(self) -> AsyncProvidersResource:
-        from .resources.providers import AsyncProvidersResource
+    def model_providers(self) -> AsyncModelProvidersResource:
+        from .resources.model_providers import AsyncModelProvidersResource
 
-        return AsyncProvidersResource(self)
+        return AsyncModelProvidersResource(self)
 
     @cached_property
     def regions(self) -> AsyncRegionsResource:
@@ -346,12 +363,6 @@ class AsyncGradientAI(AsyncAPIClient):
 
         return AsyncRegionsResource(self)
 
-    @cached_property
-    def indexing_jobs(self) -> AsyncIndexingJobsResource:
-        from .resources.indexing_jobs import AsyncIndexingJobsResource
-
-        return AsyncIndexingJobsResource(self)
-
     @cached_property
     def knowledge_bases(self) -> AsyncKnowledgeBasesResource:
         from .resources.knowledge_bases import AsyncKnowledgeBasesResource
@@ -393,6 +404,8 @@ class AsyncGradientAI(AsyncAPIClient):
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
+        if api_key is None:
+            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -404,10 +417,22 @@ class AsyncGradientAI(AsyncAPIClient):
             **self._custom_headers,
         }
 
+    @override
+    def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
+        if self.api_key and headers.get("Authorization"):
+            return
+        if isinstance(custom_headers.get("Authorization"), Omit):
+            return
+
+        raise TypeError(
+            '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"'
+        )
+
     def copy(
         self,
         *,
         api_key: str | None = None,
+        inference_key: str | None = None,
         base_url: str | httpx.URL | None = None,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
         http_client: httpx.AsyncClient | None = None,
@@ -442,6 +467,7 @@ class AsyncGradientAI(AsyncAPIClient):
         http_client = http_client or self._client
         client = self.__class__(
             api_key=api_key or self.api_key,
+            inference_key=inference_key or self.inference_key,
             base_url=base_url or self.base_url,
             timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
             http_client=http_client,
@@ -504,10 +530,10 @@ class GradientAIWithRawResponse:
         return AgentsResourceWithRawResponse(self._client.agents)
 
     @cached_property
-    def providers(self) -> providers.ProvidersResourceWithRawResponse:
-        from .resources.providers import ProvidersResourceWithRawResponse
+    def model_providers(self) -> model_providers.ModelProvidersResourceWithRawResponse:
+        from .resources.model_providers import ModelProvidersResourceWithRawResponse
 
-        return ProvidersResourceWithRawResponse(self._client.providers)
+        return ModelProvidersResourceWithRawResponse(self._client.model_providers)
 
     @cached_property
     def regions(self) -> regions.RegionsResourceWithRawResponse:
@@ -515,12 +541,6 @@ class GradientAIWithRawResponse:
 
         return RegionsResourceWithRawResponse(self._client.regions)
 
-    @cached_property
-    def indexing_jobs(self) -> indexing_jobs.IndexingJobsResourceWithRawResponse:
-        from .resources.indexing_jobs import IndexingJobsResourceWithRawResponse
-
-        return IndexingJobsResourceWithRawResponse(self._client.indexing_jobs)
-
     @cached_property
     def knowledge_bases(self) -> knowledge_bases.KnowledgeBasesResourceWithRawResponse:
         from .resources.knowledge_bases import KnowledgeBasesResourceWithRawResponse
@@ -559,10 +579,10 @@ class AsyncGradientAIWithRawResponse:
         return AsyncAgentsResourceWithRawResponse(self._client.agents)
 
     @cached_property
-    def providers(self) -> providers.AsyncProvidersResourceWithRawResponse:
-        from .resources.providers import AsyncProvidersResourceWithRawResponse
+    def model_providers(self) -> model_providers.AsyncModelProvidersResourceWithRawResponse:
+        from .resources.model_providers import AsyncModelProvidersResourceWithRawResponse
 
-        return AsyncProvidersResourceWithRawResponse(self._client.providers)
+        return AsyncModelProvidersResourceWithRawResponse(self._client.model_providers)
 
     @cached_property
     def regions(self) -> regions.AsyncRegionsResourceWithRawResponse:
@@ -570,12 +590,6 @@ class AsyncGradientAIWithRawResponse:
 
         return AsyncRegionsResourceWithRawResponse(self._client.regions)
 
-    @cached_property
-    def indexing_jobs(self) -> indexing_jobs.AsyncIndexingJobsResourceWithRawResponse:
-        from .resources.indexing_jobs import AsyncIndexingJobsResourceWithRawResponse
-
-        return AsyncIndexingJobsResourceWithRawResponse(self._client.indexing_jobs)
-
     @cached_property
     def knowledge_bases(self) -> knowledge_bases.AsyncKnowledgeBasesResourceWithRawResponse:
         from .resources.knowledge_bases import AsyncKnowledgeBasesResourceWithRawResponse
@@ -614,10 +628,10 @@ class GradientAIWithStreamedResponse:
         return AgentsResourceWithStreamingResponse(self._client.agents)
 
     @cached_property
-    def providers(self) -> providers.ProvidersResourceWithStreamingResponse:
-        from .resources.providers import ProvidersResourceWithStreamingResponse
+    def model_providers(self) -> model_providers.ModelProvidersResourceWithStreamingResponse:
+        from .resources.model_providers import ModelProvidersResourceWithStreamingResponse
 
-        return ProvidersResourceWithStreamingResponse(self._client.providers)
+        return ModelProvidersResourceWithStreamingResponse(self._client.model_providers)
 
     @cached_property
     def regions(self) -> regions.RegionsResourceWithStreamingResponse:
@@ -625,12 +639,6 @@ class GradientAIWithStreamedResponse:
 
         return RegionsResourceWithStreamingResponse(self._client.regions)
 
-    @cached_property
-    def indexing_jobs(self) -> indexing_jobs.IndexingJobsResourceWithStreamingResponse:
-        from .resources.indexing_jobs import IndexingJobsResourceWithStreamingResponse
-
-        return IndexingJobsResourceWithStreamingResponse(self._client.indexing_jobs)
-
     @cached_property
     def knowledge_bases(self) -> knowledge_bases.KnowledgeBasesResourceWithStreamingResponse:
         from .resources.knowledge_bases import KnowledgeBasesResourceWithStreamingResponse
@@ -669,10 +677,10 @@ class AsyncGradientAIWithStreamedResponse:
         return AsyncAgentsResourceWithStreamingResponse(self._client.agents)
 
     @cached_property
-    def providers(self) -> providers.AsyncProvidersResourceWithStreamingResponse:
-        from .resources.providers import AsyncProvidersResourceWithStreamingResponse
+    def model_providers(self) -> model_providers.AsyncModelProvidersResourceWithStreamingResponse:
+        from .resources.model_providers import AsyncModelProvidersResourceWithStreamingResponse
 
-        return AsyncProvidersResourceWithStreamingResponse(self._client.providers)
+        return AsyncModelProvidersResourceWithStreamingResponse(self._client.model_providers)
 
     @cached_property
     def regions(self) -> regions.AsyncRegionsResourceWithStreamingResponse:
@@ -680,12 +688,6 @@ class AsyncGradientAIWithStreamedResponse:
 
         return AsyncRegionsResourceWithStreamingResponse(self._client.regions)
 
-    @cached_property
-    def indexing_jobs(self) -> indexing_jobs.AsyncIndexingJobsResourceWithStreamingResponse:
-        from .resources.indexing_jobs import AsyncIndexingJobsResourceWithStreamingResponse
-
-        return AsyncIndexingJobsResourceWithStreamingResponse(self._client.indexing_jobs)
-
     @cached_property
     def knowledge_bases(self) -> knowledge_bases.AsyncKnowledgeBasesResourceWithStreamingResponse:
         from .resources.knowledge_bases import AsyncKnowledgeBasesResourceWithStreamingResponse

{gradientai → do_gradientai}/_response.py

@@ -218,7 +218,7 @@ class BaseAPIResponse(Generic[R]):
             and issubclass(origin, pydantic.BaseModel)
         ):
             raise TypeError(
-                "Pydantic models must subclass our base model type, e.g. `from gradientai import BaseModel`"
+                "Pydantic models must subclass our base model type, e.g. `from do_gradientai import BaseModel`"
             )
 
         if (
@@ -285,7 +285,7 @@ class APIResponse(BaseAPIResponse[R]):
         the `to` argument, e.g.
 
         ```py
-        from gradientai import BaseModel
+        from do_gradientai import BaseModel
 
 
         class MyModel(BaseModel):
@@ -387,7 +387,7 @@ class AsyncAPIResponse(BaseAPIResponse[R]):
         the `to` argument, e.g.
 
         ```py
-        from gradientai import BaseModel
+        from do_gradientai import BaseModel
 
 
         class MyModel(BaseModel):
@@ -558,7 +558,7 @@ class AsyncStreamedBinaryAPIResponse(AsyncAPIResponse[bytes]):
 class MissingStreamClassError(TypeError):
     def __init__(self) -> None:
         super().__init__(
-            "The `stream` argument was set to `True` but the `stream_cls` argument was not given. See `gradientai._streaming` for reference",
+            "The `stream` argument was set to `True` but the `stream_cls` argument was not given. See `do_gradientai._streaming` for reference",
         )
 
 

{gradientai → do_gradientai}/_types.py

@@ -81,7 +81,7 @@ HttpxRequestFiles = Union[Mapping[str, HttpxFileTypes], Sequence[Tuple[str, Http
 # This unfortunately means that you will either have
 # to import this type and pass it explicitly:
 #
-# from gradientai import NoneType
+# from do_gradientai import NoneType
 # client.get('/foo', cast_to=NoneType)
 #
 # or build it yourself:

{gradientai → do_gradientai}/_utils/_logs.py

@@ -1,12 +1,12 @@
 import os
 import logging
 
-logger: logging.Logger = logging.getLogger("gradientai")
+logger: logging.Logger = logging.getLogger("do_gradientai")
 httpx_logger: logging.Logger = logging.getLogger("httpx")
 
 
 def _basic_config() -> None:
-    # e.g. [2023-10-05 14:12:26 - gradientai._base_client:818 - DEBUG] HTTP Request: POST http://127.0.0.1:4010/foo/bar "200 OK"
+    # e.g. [2023-10-05 14:12:26 - do_gradientai._base_client:818 - DEBUG] HTTP Request: POST http://127.0.0.1:4010/foo/bar "200 OK"
     logging.basicConfig(
         format="[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s",
         datefmt="%Y-%m-%d %H:%M:%S",

{gradientai → do_gradientai}/_utils/_resources_proxy.py

@@ -7,17 +7,17 @@ from ._proxy import LazyProxy
 
 
 class ResourcesProxy(LazyProxy[Any]):
-    """A proxy for the `gradientai.resources` module.
+    """A proxy for the `do_gradientai.resources` module.
 
-    This is used so that we can lazily import `gradientai.resources` only when
-    needed *and* so that users can just import `gradientai` and reference `gradientai.resources`
+    This is used so that we can lazily import `do_gradientai.resources` only when
+    needed *and* so that users can just import `do_gradientai` and reference `do_gradientai.resources`
     """
 
     @override
     def __load__(self) -> Any:
         import importlib
 
-        mod = importlib.import_module("gradientai.resources")
+        mod = importlib.import_module("do_gradientai.resources")
         return mod
 
 

do_gradientai/_version.py

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

{gradientai → do_gradientai}/resources/__init__.py

@@ -40,22 +40,6 @@ from .inference import (
     InferenceResourceWithStreamingResponse,
     AsyncInferenceResourceWithStreamingResponse,
 )
-from .providers import (
-    ProvidersResource,
-    AsyncProvidersResource,
-    ProvidersResourceWithRawResponse,
-    AsyncProvidersResourceWithRawResponse,
-    ProvidersResourceWithStreamingResponse,
-    AsyncProvidersResourceWithStreamingResponse,
-)
-from .indexing_jobs import (
-    IndexingJobsResource,
-    AsyncIndexingJobsResource,
-    IndexingJobsResourceWithRawResponse,
-    AsyncIndexingJobsResourceWithRawResponse,
-    IndexingJobsResourceWithStreamingResponse,
-    AsyncIndexingJobsResourceWithStreamingResponse,
-)
 from .knowledge_bases import (
     KnowledgeBasesResource,
     AsyncKnowledgeBasesResource,
@@ -64,6 +48,14 @@ from .knowledge_bases import (
     KnowledgeBasesResourceWithStreamingResponse,
     AsyncKnowledgeBasesResourceWithStreamingResponse,
 )
+from .model_providers import (
+    ModelProvidersResource,
+    AsyncModelProvidersResource,
+    ModelProvidersResourceWithRawResponse,
+    AsyncModelProvidersResourceWithRawResponse,
+    ModelProvidersResourceWithStreamingResponse,
+    AsyncModelProvidersResourceWithStreamingResponse,
+)
 
 __all__ = [
     "AgentsResource",
@@ -72,24 +64,18 @@ __all__ = [
     "AsyncAgentsResourceWithRawResponse",
     "AgentsResourceWithStreamingResponse",
     "AsyncAgentsResourceWithStreamingResponse",
-    "ProvidersResource",
-    "AsyncProvidersResource",
-    "ProvidersResourceWithRawResponse",
-    "AsyncProvidersResourceWithRawResponse",
-    "ProvidersResourceWithStreamingResponse",
-    "AsyncProvidersResourceWithStreamingResponse",
+    "ModelProvidersResource",
+    "AsyncModelProvidersResource",
+    "ModelProvidersResourceWithRawResponse",
+    "AsyncModelProvidersResourceWithRawResponse",
+    "ModelProvidersResourceWithStreamingResponse",
+    "AsyncModelProvidersResourceWithStreamingResponse",
     "RegionsResource",
     "AsyncRegionsResource",
     "RegionsResourceWithRawResponse",
     "AsyncRegionsResourceWithRawResponse",
     "RegionsResourceWithStreamingResponse",
     "AsyncRegionsResourceWithStreamingResponse",
-    "IndexingJobsResource",
-    "AsyncIndexingJobsResource",
-    "IndexingJobsResourceWithRawResponse",
-    "AsyncIndexingJobsResourceWithRawResponse",
-    "IndexingJobsResourceWithStreamingResponse",
-    "AsyncIndexingJobsResourceWithStreamingResponse",
     "KnowledgeBasesResource",
     "AsyncKnowledgeBasesResource",
     "KnowledgeBasesResourceWithRawResponse",

do_gradientai/resources/agents/__init__.py

@@ -0,0 +1,145 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .agents import (
+    AgentsResource,
+    AsyncAgentsResource,
+    AgentsResourceWithRawResponse,
+    AsyncAgentsResourceWithRawResponse,
+    AgentsResourceWithStreamingResponse,
+    AsyncAgentsResourceWithStreamingResponse,
+)
+from .routes import (
+    RoutesResource,
+    AsyncRoutesResource,
+    RoutesResourceWithRawResponse,
+    AsyncRoutesResourceWithRawResponse,
+    RoutesResourceWithStreamingResponse,
+    AsyncRoutesResourceWithStreamingResponse,
+)
+from .api_keys import (
+    APIKeysResource,
+    AsyncAPIKeysResource,
+    APIKeysResourceWithRawResponse,
+    AsyncAPIKeysResourceWithRawResponse,
+    APIKeysResourceWithStreamingResponse,
+    AsyncAPIKeysResourceWithStreamingResponse,
+)
+from .versions import (
+    VersionsResource,
+    AsyncVersionsResource,
+    VersionsResourceWithRawResponse,
+    AsyncVersionsResourceWithRawResponse,
+    VersionsResourceWithStreamingResponse,
+    AsyncVersionsResourceWithStreamingResponse,
+)
+from .functions import (
+    FunctionsResource,
+    AsyncFunctionsResource,
+    FunctionsResourceWithRawResponse,
+    AsyncFunctionsResourceWithRawResponse,
+    FunctionsResourceWithStreamingResponse,
+    AsyncFunctionsResourceWithStreamingResponse,
+)
+from .evaluation_runs import (
+    EvaluationRunsResource,
+    AsyncEvaluationRunsResource,
+    EvaluationRunsResourceWithRawResponse,
+    AsyncEvaluationRunsResourceWithRawResponse,
+    EvaluationRunsResourceWithStreamingResponse,
+    AsyncEvaluationRunsResourceWithStreamingResponse,
+)
+from .knowledge_bases import (
+    KnowledgeBasesResource,
+    AsyncKnowledgeBasesResource,
+    KnowledgeBasesResourceWithRawResponse,
+    AsyncKnowledgeBasesResourceWithRawResponse,
+    KnowledgeBasesResourceWithStreamingResponse,
+    AsyncKnowledgeBasesResourceWithStreamingResponse,
+)
+from .evaluation_metrics import (
+    EvaluationMetricsResource,
+    AsyncEvaluationMetricsResource,
+    EvaluationMetricsResourceWithRawResponse,
+    AsyncEvaluationMetricsResourceWithRawResponse,
+    EvaluationMetricsResourceWithStreamingResponse,
+    AsyncEvaluationMetricsResourceWithStreamingResponse,
+)
+from .evaluation_datasets import (
+    EvaluationDatasetsResource,
+    AsyncEvaluationDatasetsResource,
+    EvaluationDatasetsResourceWithRawResponse,
+    AsyncEvaluationDatasetsResourceWithRawResponse,
+    EvaluationDatasetsResourceWithStreamingResponse,
+    AsyncEvaluationDatasetsResourceWithStreamingResponse,
+)
+from .evaluation_test_cases import (
+    EvaluationTestCasesResource,
+    AsyncEvaluationTestCasesResource,
+    EvaluationTestCasesResourceWithRawResponse,
+    AsyncEvaluationTestCasesResourceWithRawResponse,
+    EvaluationTestCasesResourceWithStreamingResponse,
+    AsyncEvaluationTestCasesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "APIKeysResource",
+    "AsyncAPIKeysResource",
+    "APIKeysResourceWithRawResponse",
+    "AsyncAPIKeysResourceWithRawResponse",
+    "APIKeysResourceWithStreamingResponse",
+    "AsyncAPIKeysResourceWithStreamingResponse",
+    "EvaluationMetricsResource",
+    "AsyncEvaluationMetricsResource",
+    "EvaluationMetricsResourceWithRawResponse",
+    "AsyncEvaluationMetricsResourceWithRawResponse",
+    "EvaluationMetricsResourceWithStreamingResponse",
+    "AsyncEvaluationMetricsResourceWithStreamingResponse",
+    "EvaluationRunsResource",
+    "AsyncEvaluationRunsResource",
+    "EvaluationRunsResourceWithRawResponse",
+    "AsyncEvaluationRunsResourceWithRawResponse",
+    "EvaluationRunsResourceWithStreamingResponse",
+    "AsyncEvaluationRunsResourceWithStreamingResponse",
+    "EvaluationTestCasesResource",
+    "AsyncEvaluationTestCasesResource",
+    "EvaluationTestCasesResourceWithRawResponse",
+    "AsyncEvaluationTestCasesResourceWithRawResponse",
+    "EvaluationTestCasesResourceWithStreamingResponse",
+    "AsyncEvaluationTestCasesResourceWithStreamingResponse",
+    "EvaluationDatasetsResource",
+    "AsyncEvaluationDatasetsResource",
+    "EvaluationDatasetsResourceWithRawResponse",
+    "AsyncEvaluationDatasetsResourceWithRawResponse",
+    "EvaluationDatasetsResourceWithStreamingResponse",
+    "AsyncEvaluationDatasetsResourceWithStreamingResponse",
+    "FunctionsResource",
+    "AsyncFunctionsResource",
+    "FunctionsResourceWithRawResponse",
+    "AsyncFunctionsResourceWithRawResponse",
+    "FunctionsResourceWithStreamingResponse",
+    "AsyncFunctionsResourceWithStreamingResponse",
+    "VersionsResource",
+    "AsyncVersionsResource",
+    "VersionsResourceWithRawResponse",
+    "AsyncVersionsResourceWithRawResponse",
+    "VersionsResourceWithStreamingResponse",
+    "AsyncVersionsResourceWithStreamingResponse",
+    "KnowledgeBasesResource",
+    "AsyncKnowledgeBasesResource",
+    "KnowledgeBasesResourceWithRawResponse",
+    "AsyncKnowledgeBasesResourceWithRawResponse",
+    "KnowledgeBasesResourceWithStreamingResponse",
+    "AsyncKnowledgeBasesResourceWithStreamingResponse",
+    "RoutesResource",
+    "AsyncRoutesResource",
+    "RoutesResourceWithRawResponse",
+    "AsyncRoutesResourceWithRawResponse",
+    "RoutesResourceWithStreamingResponse",
+    "AsyncRoutesResourceWithStreamingResponse",
+    "AgentsResource",
+    "AsyncAgentsResource",
+    "AgentsResourceWithRawResponse",
+    "AsyncAgentsResourceWithRawResponse",
+    "AgentsResourceWithStreamingResponse",
+    "AsyncAgentsResourceWithStreamingResponse",
+]