anchorbrowser 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

anchorbrowser/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import agent, tools, events, browser, profiles, extensions
+from .resources import task, agent, tools, events, browser, profiles, extensions, batch_sessions
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, AnchorbrowserError
 from ._base_client import (
@@ -51,6 +51,8 @@ class Anchorbrowser(SyncAPIClient):
     browser: browser.BrowserResource
     agent: agent.AgentResource
     events: events.EventsResource
+    batch_sessions: batch_sessions.BatchSessionsResource
+    task: task.TaskResource
     with_raw_response: AnchorbrowserWithRawResponse
     with_streaming_response: AnchorbrowserWithStreamedResponse
 
@@ -115,6 +117,8 @@ class Anchorbrowser(SyncAPIClient):
         self.browser = browser.BrowserResource(self)
         self.agent = agent.AgentResource(self)
         self.events = events.EventsResource(self)
+        self.batch_sessions = batch_sessions.BatchSessionsResource(self)
+        self.task = task.TaskResource(self)
         self.with_raw_response = AnchorbrowserWithRawResponse(self)
         self.with_streaming_response = AnchorbrowserWithStreamedResponse(self)
 
@@ -231,6 +235,8 @@ class AsyncAnchorbrowser(AsyncAPIClient):
     browser: browser.AsyncBrowserResource
     agent: agent.AsyncAgentResource
     events: events.AsyncEventsResource
+    batch_sessions: batch_sessions.AsyncBatchSessionsResource
+    task: task.AsyncTaskResource
     with_raw_response: AsyncAnchorbrowserWithRawResponse
     with_streaming_response: AsyncAnchorbrowserWithStreamedResponse
 
@@ -295,6 +301,8 @@ class AsyncAnchorbrowser(AsyncAPIClient):
         self.browser = browser.AsyncBrowserResource(self)
         self.agent = agent.AsyncAgentResource(self)
         self.events = events.AsyncEventsResource(self)
+        self.batch_sessions = batch_sessions.AsyncBatchSessionsResource(self)
+        self.task = task.AsyncTaskResource(self)
         self.with_raw_response = AsyncAnchorbrowserWithRawResponse(self)
         self.with_streaming_response = AsyncAnchorbrowserWithStreamedResponse(self)
 
@@ -412,6 +420,8 @@ class AnchorbrowserWithRawResponse:
         self.browser = browser.BrowserResourceWithRawResponse(client.browser)
         self.agent = agent.AgentResourceWithRawResponse(client.agent)
         self.events = events.EventsResourceWithRawResponse(client.events)
+        self.batch_sessions = batch_sessions.BatchSessionsResourceWithRawResponse(client.batch_sessions)
+        self.task = task.TaskResourceWithRawResponse(client.task)
 
 
 class AsyncAnchorbrowserWithRawResponse:
@@ -423,6 +433,8 @@ class AsyncAnchorbrowserWithRawResponse:
         self.browser = browser.AsyncBrowserResourceWithRawResponse(client.browser)
         self.agent = agent.AsyncAgentResourceWithRawResponse(client.agent)
         self.events = events.AsyncEventsResourceWithRawResponse(client.events)
+        self.batch_sessions = batch_sessions.AsyncBatchSessionsResourceWithRawResponse(client.batch_sessions)
+        self.task = task.AsyncTaskResourceWithRawResponse(client.task)
 
 
 class AnchorbrowserWithStreamedResponse:
@@ -434,6 +446,8 @@ class AnchorbrowserWithStreamedResponse:
         self.browser = browser.BrowserResourceWithStreamingResponse(client.browser)
         self.agent = agent.AgentResourceWithStreamingResponse(client.agent)
         self.events = events.EventsResourceWithStreamingResponse(client.events)
+        self.batch_sessions = batch_sessions.BatchSessionsResourceWithStreamingResponse(client.batch_sessions)
+        self.task = task.TaskResourceWithStreamingResponse(client.task)
 
 
 class AsyncAnchorbrowserWithStreamedResponse:
@@ -445,6 +459,8 @@ class AsyncAnchorbrowserWithStreamedResponse:
         self.browser = browser.AsyncBrowserResourceWithStreamingResponse(client.browser)
         self.agent = agent.AsyncAgentResourceWithStreamingResponse(client.agent)
         self.events = events.AsyncEventsResourceWithStreamingResponse(client.events)
+        self.batch_sessions = batch_sessions.AsyncBatchSessionsResourceWithStreamingResponse(client.batch_sessions)
+        self.task = task.AsyncTaskResourceWithStreamingResponse(client.task)
 
 
 Client = Anchorbrowser

anchorbrowser/_models.py

@@ -260,6 +260,7 @@ class BaseModel(pydantic.BaseModel):
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
             context: dict[str, Any] | None = None,
@@ -320,11 +321,13 @@ class BaseModel(pydantic.BaseModel):
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
             context: dict[str, Any] | None = None,
             fallback: Callable[[Any], Any] | None = None,
             serialize_as_any: bool = False,
+            ensure_ascii: bool = True,
         ) -> str:
             """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump_json
 

anchorbrowser/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "anchorbrowser"
-__version__ = "0.1.1"  # x-release-please-version
+__version__ = "0.3.0"  # x-release-please-version

anchorbrowser/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .task import (
+    TaskResource,
+    AsyncTaskResource,
+    TaskResourceWithRawResponse,
+    AsyncTaskResourceWithRawResponse,
+    TaskResourceWithStreamingResponse,
+    AsyncTaskResourceWithStreamingResponse,
+)
 from .tools import (
     ToolsResource,
     AsyncToolsResource,
@@ -40,6 +48,14 @@ from .extensions import (
     ExtensionsResourceWithStreamingResponse,
     AsyncExtensionsResourceWithStreamingResponse,
 )
+from .batch_sessions import (
+    BatchSessionsResource,
+    AsyncBatchSessionsResource,
+    BatchSessionsResourceWithRawResponse,
+    AsyncBatchSessionsResourceWithRawResponse,
+    BatchSessionsResourceWithStreamingResponse,
+    AsyncBatchSessionsResourceWithStreamingResponse,
+)
 
 __all__ = [
     "ProfilesResource",
@@ -72,4 +88,16 @@ __all__ = [
     "AsyncEventsResourceWithRawResponse",
     "EventsResourceWithStreamingResponse",
     "AsyncEventsResourceWithStreamingResponse",
+    "BatchSessionsResource",
+    "AsyncBatchSessionsResource",
+    "BatchSessionsResourceWithRawResponse",
+    "AsyncBatchSessionsResourceWithRawResponse",
+    "BatchSessionsResourceWithStreamingResponse",
+    "AsyncBatchSessionsResourceWithStreamingResponse",
+    "TaskResource",
+    "AsyncTaskResource",
+    "TaskResourceWithRawResponse",
+    "AsyncTaskResourceWithRawResponse",
+    "TaskResourceWithStreamingResponse",
+    "AsyncTaskResourceWithStreamingResponse",
 ]

anchorbrowser/resources/batch_sessions.py

@@ -0,0 +1,288 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+
+import httpx
+
+from ..types import batch_session_create_params
+from .._types import Body, Omit, Query, Headers, 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.batch_session_create_response import BatchSessionCreateResponse
+from ..types.batch_session_retrieve_response import BatchSessionRetrieveResponse
+
+__all__ = ["BatchSessionsResource", "AsyncBatchSessionsResource"]
+
+
+class BatchSessionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BatchSessionsResourceWithRawResponse:
+        """
+        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/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return BatchSessionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BatchSessionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return BatchSessionsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        count: int,
+        configuration: batch_session_create_params.Configuration | Omit = omit,
+        metadata: Dict[str, object] | 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,
+    ) -> BatchSessionCreateResponse:
+        """Creates multiple browser sessions in a single batch operation.
+
+        This endpoint
+        allows you to create up to 5,000 browser sessions simultaneously with the same
+        configuration.
+
+        The batch will be processed asynchronously, and you can monitor progress using
+        the batch status endpoint.
+
+        Args:
+          count: Number of sessions to create in the batch (1-1000)
+
+          configuration: Configuration that applies to all sessions in the batch
+
+          metadata: Optional batch-level metadata for identification and organization
+
+          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._post(
+            "/v1/batch-sessions",
+            body=maybe_transform(
+                {
+                    "count": count,
+                    "configuration": configuration,
+                    "metadata": metadata,
+                },
+                batch_session_create_params.BatchSessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        batch_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,
+    ) -> BatchSessionRetrieveResponse:
+        """
+        Retrieves detailed status information for a specific batch, including progress,
+        individual session details, and any errors that occurred.
+
+        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 batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return self._get(
+            f"/v1/batch-sessions/{batch_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionRetrieveResponse,
+        )
+
+
+class AsyncBatchSessionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBatchSessionsResourceWithRawResponse:
+        """
+        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/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBatchSessionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBatchSessionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncBatchSessionsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        count: int,
+        configuration: batch_session_create_params.Configuration | Omit = omit,
+        metadata: Dict[str, object] | 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,
+    ) -> BatchSessionCreateResponse:
+        """Creates multiple browser sessions in a single batch operation.
+
+        This endpoint
+        allows you to create up to 5,000 browser sessions simultaneously with the same
+        configuration.
+
+        The batch will be processed asynchronously, and you can monitor progress using
+        the batch status endpoint.
+
+        Args:
+          count: Number of sessions to create in the batch (1-1000)
+
+          configuration: Configuration that applies to all sessions in the batch
+
+          metadata: Optional batch-level metadata for identification and organization
+
+          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._post(
+            "/v1/batch-sessions",
+            body=await async_maybe_transform(
+                {
+                    "count": count,
+                    "configuration": configuration,
+                    "metadata": metadata,
+                },
+                batch_session_create_params.BatchSessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        batch_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,
+    ) -> BatchSessionRetrieveResponse:
+        """
+        Retrieves detailed status information for a specific batch, including progress,
+        individual session details, and any errors that occurred.
+
+        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 batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return await self._get(
+            f"/v1/batch-sessions/{batch_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionRetrieveResponse,
+        )
+
+
+class BatchSessionsResourceWithRawResponse:
+    def __init__(self, batch_sessions: BatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = to_raw_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            batch_sessions.retrieve,
+        )
+
+
+class AsyncBatchSessionsResourceWithRawResponse:
+    def __init__(self, batch_sessions: AsyncBatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = async_to_raw_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            batch_sessions.retrieve,
+        )
+
+
+class BatchSessionsResourceWithStreamingResponse:
+    def __init__(self, batch_sessions: BatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = to_streamed_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            batch_sessions.retrieve,
+        )
+
+
+class AsyncBatchSessionsResourceWithStreamingResponse:
+    def __init__(self, batch_sessions: AsyncBatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = async_to_streamed_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            batch_sessions.retrieve,
+        )

anchorbrowser/resources/profiles.py

@@ -6,7 +6,7 @@ from typing_extensions import Literal
 
 import httpx
 
-from ..types import profile_create_params, profile_update_params
+from ..types import profile_create_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -137,57 +137,6 @@ class ProfilesResource(SyncAPIResource):
             cast_to=ProfileRetrieveResponse,
         )
 
-    def update(
-        self,
-        name: str,
-        *,
-        description: str | Omit = omit,
-        session_id: str | Omit = omit,
-        source: Literal["session"] | 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,
-    ) -> SuccessResponse:
-        """
-        Updates the description or data of an existing profile using a browser session.
-
-        Args:
-          description: The new description for the profile.
-
-          session_id: The browser session ID is required if the source is set to `session`. The
-              browser session must belong to the user and be active.
-
-          source: The source of the profile data. Currently, only `session` is supported.
-
-          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 name:
-            raise ValueError(f"Expected a non-empty value for `name` but received {name!r}")
-        return self._put(
-            f"/v1/profiles/{name}",
-            body=maybe_transform(
-                {
-                    "description": description,
-                    "session_id": session_id,
-                    "source": source,
-                },
-                profile_update_params.ProfileUpdateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=SuccessResponse,
-        )
-
     def list(
         self,
         *,
@@ -353,57 +302,6 @@ class AsyncProfilesResource(AsyncAPIResource):
             cast_to=ProfileRetrieveResponse,
         )
 
-    async def update(
-        self,
-        name: str,
-        *,
-        description: str | Omit = omit,
-        session_id: str | Omit = omit,
-        source: Literal["session"] | 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,
-    ) -> SuccessResponse:
-        """
-        Updates the description or data of an existing profile using a browser session.
-
-        Args:
-          description: The new description for the profile.
-
-          session_id: The browser session ID is required if the source is set to `session`. The
-              browser session must belong to the user and be active.
-
-          source: The source of the profile data. Currently, only `session` is supported.
-
-          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 name:
-            raise ValueError(f"Expected a non-empty value for `name` but received {name!r}")
-        return await self._put(
-            f"/v1/profiles/{name}",
-            body=await async_maybe_transform(
-                {
-                    "description": description,
-                    "session_id": session_id,
-                    "source": source,
-                },
-                profile_update_params.ProfileUpdateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=SuccessResponse,
-        )
-
     async def list(
         self,
         *,
@@ -467,9 +365,6 @@ class ProfilesResourceWithRawResponse:
         self.retrieve = to_raw_response_wrapper(
             profiles.retrieve,
         )
-        self.update = to_raw_response_wrapper(
-            profiles.update,
-        )
         self.list = to_raw_response_wrapper(
             profiles.list,
         )
@@ -488,9 +383,6 @@ class AsyncProfilesResourceWithRawResponse:
         self.retrieve = async_to_raw_response_wrapper(
             profiles.retrieve,
         )
-        self.update = async_to_raw_response_wrapper(
-            profiles.update,
-        )
         self.list = async_to_raw_response_wrapper(
             profiles.list,
         )
@@ -509,9 +401,6 @@ class ProfilesResourceWithStreamingResponse:
         self.retrieve = to_streamed_response_wrapper(
             profiles.retrieve,
         )
-        self.update = to_streamed_response_wrapper(
-            profiles.update,
-        )
         self.list = to_streamed_response_wrapper(
             profiles.list,
         )
@@ -530,9 +419,6 @@ class AsyncProfilesResourceWithStreamingResponse:
         self.retrieve = async_to_streamed_response_wrapper(
             profiles.retrieve,
         )
-        self.update = async_to_streamed_response_wrapper(
-            profiles.update,
-        )
         self.list = async_to_streamed_response_wrapper(
             profiles.list,
         )

anchorbrowser/resources/sessions/__init__.py

@@ -8,6 +8,14 @@ from .all import (
     AllResourceWithStreamingResponse,
     AsyncAllResourceWithStreamingResponse,
 )
+from .agent import (
+    AgentResource,
+    AsyncAgentResource,
+    AgentResourceWithRawResponse,
+    AsyncAgentResourceWithRawResponse,
+    AgentResourceWithStreamingResponse,
+    AsyncAgentResourceWithStreamingResponse,
+)
 from .mouse import (
     MouseResource,
     AsyncMouseResource,
@@ -78,6 +86,12 @@ __all__ = [
     "AsyncClipboardResource",
     "ClipboardResourceWithRawResponse",
     "AsyncClipboardResourceWithRawResponse",
+    "AgentResource",
+    "AsyncAgentResource",
+    "AgentResourceWithRawResponse",
+    "AsyncAgentResourceWithRawResponse",
+    "AgentResourceWithStreamingResponse",
+    "AsyncAgentResourceWithStreamingResponse",
     "ClipboardResourceWithStreamingResponse",
     "AsyncClipboardResourceWithStreamingResponse",
     "SessionsResource",

anchorbrowser/resources/sessions/agent/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .agent import (
+    AgentResource,
+    AsyncAgentResource,
+    AgentResourceWithRawResponse,
+    AsyncAgentResourceWithRawResponse,
+    AgentResourceWithStreamingResponse,
+    AsyncAgentResourceWithStreamingResponse,
+)
+from .files import (
+    FilesResource,
+    AsyncFilesResource,
+    FilesResourceWithRawResponse,
+    AsyncFilesResourceWithRawResponse,
+    FilesResourceWithStreamingResponse,
+    AsyncFilesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "FilesResource",
+    "AsyncFilesResource",
+    "FilesResourceWithRawResponse",
+    "AsyncFilesResourceWithRawResponse",
+    "FilesResourceWithStreamingResponse",
+    "AsyncFilesResourceWithStreamingResponse",
+    "AgentResource",
+    "AsyncAgentResource",
+    "AgentResourceWithRawResponse",
+    "AsyncAgentResourceWithRawResponse",
+    "AgentResourceWithStreamingResponse",
+    "AsyncAgentResourceWithStreamingResponse",
+]