opencode-python-sdk 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

opencode/resources/debug.py

@@ -11,6 +11,12 @@ from typing import TYPE_CHECKING, cast
 
 from .._base_client import RequestOptions
 from .._resource import AsyncAPIResource, SyncAPIResource
+from .._response import (
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+)
 from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout
 
 if TYPE_CHECKING:
@@ -25,6 +31,16 @@ __all__ = ["DebugResource", "AsyncDebugResource"]
 class DebugLocationResource(SyncAPIResource):
     """Operations under ``client.debug.location`` (OpenCode ``debug.location``)."""
 
+    @cached_property
+    def with_raw_response(self) -> DebugLocationResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return DebugLocationResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DebugLocationResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return DebugLocationResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -77,20 +93,41 @@ class DebugLocationResource(SyncAPIResource):
 
         ``DELETE /api/debug/location``
         """
-        self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path="/api/debug/location",
-                query={"location": self._location(location)},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="DELETE",
+                    path="/api/debug/location",
+                    query={"location": self._location(location)},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class DebugLocationResourceWithRawResponse:
+    """``client.debug.location.with_raw_response``."""
+
+    def __init__(self, resource: DebugLocationResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.evict = to_raw_response_wrapper(resource.evict)
+
+
+class DebugLocationResourceWithStreamingResponse:
+    """``client.debug.location.with_streaming_response``."""
+
+    def __init__(self, resource: DebugLocationResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.evict = to_streamed_response_wrapper(resource.evict)
+
+
 class DebugResource(SyncAPIResource):
     """Operations under ``client.debug`` (OpenCode ``debug``)."""
 
@@ -99,10 +136,54 @@ class DebugResource(SyncAPIResource):
         """Operations under ``client.debug.location``."""
         return DebugLocationResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> DebugResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return DebugResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DebugResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return DebugResourceWithStreamingResponse(self)
+
+
+class DebugResourceWithRawResponse:
+    """``client.debug.with_raw_response``."""
+
+    def __init__(self, resource: DebugResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def location(self) -> DebugLocationResourceWithRawResponse:
+        """``client.debug.location.with_raw_response``."""
+        return DebugLocationResourceWithRawResponse(self._resource.location)
+
+
+class DebugResourceWithStreamingResponse:
+    """``client.debug.with_streaming_response``."""
+
+    def __init__(self, resource: DebugResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def location(self) -> DebugLocationResourceWithStreamingResponse:
+        """``client.debug.location.with_streaming_response``."""
+        return DebugLocationResourceWithStreamingResponse(self._resource.location)
+
 
 class AsyncDebugLocationResource(AsyncAPIResource):
     """Operations under ``client.debug.location`` (OpenCode ``debug.location``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncDebugLocationResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncDebugLocationResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDebugLocationResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncDebugLocationResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -155,20 +236,41 @@ class AsyncDebugLocationResource(AsyncAPIResource):
 
         ``DELETE /api/debug/location``
         """
-        await self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path="/api/debug/location",
-                query={"location": self._location(location)},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="DELETE",
+                    path="/api/debug/location",
+                    query={"location": self._location(location)},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class AsyncDebugLocationResourceWithRawResponse:
+    """``client.debug.location.with_raw_response``."""
+
+    def __init__(self, resource: AsyncDebugLocationResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.evict = async_to_raw_response_wrapper(resource.evict)
+
+
+class AsyncDebugLocationResourceWithStreamingResponse:
+    """``client.debug.location.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncDebugLocationResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.evict = async_to_streamed_response_wrapper(resource.evict)
+
+
 class AsyncDebugResource(AsyncAPIResource):
     """Operations under ``client.debug`` (OpenCode ``debug``)."""
 
@@ -176,3 +278,37 @@ class AsyncDebugResource(AsyncAPIResource):
     def location(self) -> AsyncDebugLocationResource:
         """Operations under ``client.debug.location``."""
         return AsyncDebugLocationResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncDebugResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncDebugResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDebugResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncDebugResourceWithStreamingResponse(self)
+
+
+class AsyncDebugResourceWithRawResponse:
+    """``client.debug.with_raw_response``."""
+
+    def __init__(self, resource: AsyncDebugResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def location(self) -> AsyncDebugLocationResourceWithRawResponse:
+        """``client.debug.location.with_raw_response``."""
+        return AsyncDebugLocationResourceWithRawResponse(self._resource.location)
+
+
+class AsyncDebugResourceWithStreamingResponse:
+    """``client.debug.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncDebugResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def location(self) -> AsyncDebugLocationResourceWithStreamingResponse:
+        """``client.debug.location.with_streaming_response``."""
+        return AsyncDebugLocationResourceWithStreamingResponse(self._resource.location)

opencode/resources/event.py

@@ -5,10 +5,17 @@
 
 from __future__ import annotations
 
+from functools import cached_property
 from typing import TYPE_CHECKING
 
 from .._base_client import RequestOptions
 from .._resource import AsyncAPIResource, SyncAPIResource
+from .._response import (
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+)
 from .._streaming import AsyncStream, Stream
 from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout
 
@@ -23,6 +30,16 @@ __all__ = ["EventResource", "AsyncEventResource"]
 class EventResource(SyncAPIResource):
     """Operations under ``client.event`` (OpenCode ``event``)."""
 
+    @cached_property
+    def with_raw_response(self) -> EventResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return EventResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EventResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return EventResourceWithStreamingResponse(self)
+
     def subscribe(
         self,
         *,
@@ -54,9 +71,35 @@ class EventResource(SyncAPIResource):
         )
 
 
+class EventResourceWithRawResponse:
+    """``client.event.with_raw_response``."""
+
+    def __init__(self, resource: EventResource) -> None:
+        self._resource = resource
+        self.subscribe = to_raw_response_wrapper(resource.subscribe)
+
+
+class EventResourceWithStreamingResponse:
+    """``client.event.with_streaming_response``."""
+
+    def __init__(self, resource: EventResource) -> None:
+        self._resource = resource
+        self.subscribe = to_streamed_response_wrapper(resource.subscribe)
+
+
 class AsyncEventResource(AsyncAPIResource):
     """Operations under ``client.event`` (OpenCode ``event``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncEventResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncEventResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEventResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncEventResourceWithStreamingResponse(self)
+
     async def subscribe(
         self,
         *,
@@ -86,3 +129,19 @@ class AsyncEventResource(AsyncAPIResource):
             ),
             item_type="Event",
         )
+
+
+class AsyncEventResourceWithRawResponse:
+    """``client.event.with_raw_response``."""
+
+    def __init__(self, resource: AsyncEventResource) -> None:
+        self._resource = resource
+        self.subscribe = async_to_raw_response_wrapper(resource.subscribe)
+
+
+class AsyncEventResourceWithStreamingResponse:
+    """``client.event.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncEventResource) -> None:
+        self._resource = resource
+        self.subscribe = async_to_streamed_response_wrapper(resource.subscribe)

opencode/resources/experimental.py

@@ -14,6 +14,12 @@ from .._base_client import RequestOptions
 from .._pty import AsyncPersistentPtyAttachMixin, PersistentPtyAttachMixin
 from .._qs import encode_path_segment
 from .._resource import AsyncAPIResource, SyncAPIResource
+from .._response import (
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+)
 from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout
 
 if TYPE_CHECKING:
@@ -36,6 +42,16 @@ __all__ = ["ExperimentalResource", "AsyncExperimentalResource"]
 class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
     """Operations under ``client.experimental.persistent_pty`` (OpenCode ``experimental.persistentPty``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ExperimentalPersistentPtyResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ExperimentalPersistentPtyResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ExperimentalPersistentPtyResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ExperimentalPersistentPtyResourceWithStreamingResponse(self)
+
     def read(
         self,
         session_id: SessionID,
@@ -168,16 +184,19 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
 
         ``POST /api/experimental/persistent-pty/shutdown``
         """
-        self._client.request(
-            RequestOptions(
-                method="POST",
-                path="/api/experimental/persistent-pty/shutdown",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="POST",
+                    path="/api/experimental/persistent-pty/shutdown",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     def handoff(
@@ -339,16 +358,19 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
 
         ``DELETE /api/experimental/persistent-pty/:ptyID``
         """
-        self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="DELETE",
+                    path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     def connect_token(
@@ -390,6 +412,40 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
         )
 
 
+class ExperimentalPersistentPtyResourceWithRawResponse:
+    """``client.experimental.persistent_pty.with_raw_response``."""
+
+    def __init__(self, resource: ExperimentalPersistentPtyResource) -> None:
+        self._resource = resource
+        self.read = to_raw_response_wrapper(resource.read)
+        self.list = to_raw_response_wrapper(resource.list)
+        self.create = to_raw_response_wrapper(resource.create)
+        self.shutdown = to_raw_response_wrapper(resource.shutdown)
+        self.handoff = to_raw_response_wrapper(resource.handoff)
+        self.get = to_raw_response_wrapper(resource.get)
+        self.update = to_raw_response_wrapper(resource.update)
+        self.snapshot = to_raw_response_wrapper(resource.snapshot)
+        self.remove = to_raw_response_wrapper(resource.remove)
+        self.connect_token = to_raw_response_wrapper(resource.connect_token)
+
+
+class ExperimentalPersistentPtyResourceWithStreamingResponse:
+    """``client.experimental.persistent_pty.with_streaming_response``."""
+
+    def __init__(self, resource: ExperimentalPersistentPtyResource) -> None:
+        self._resource = resource
+        self.read = to_streamed_response_wrapper(resource.read)
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.create = to_streamed_response_wrapper(resource.create)
+        self.shutdown = to_streamed_response_wrapper(resource.shutdown)
+        self.handoff = to_streamed_response_wrapper(resource.handoff)
+        self.get = to_streamed_response_wrapper(resource.get)
+        self.update = to_streamed_response_wrapper(resource.update)
+        self.snapshot = to_streamed_response_wrapper(resource.snapshot)
+        self.remove = to_streamed_response_wrapper(resource.remove)
+        self.connect_token = to_streamed_response_wrapper(resource.connect_token)
+
+
 class ExperimentalResource(SyncAPIResource):
     """Operations under ``client.experimental`` (OpenCode ``experimental``)."""
 
@@ -398,10 +454,54 @@ class ExperimentalResource(SyncAPIResource):
         """Operations under ``client.experimental.persistent_pty``."""
         return ExperimentalPersistentPtyResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> ExperimentalResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ExperimentalResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ExperimentalResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ExperimentalResourceWithStreamingResponse(self)
+
+
+class ExperimentalResourceWithRawResponse:
+    """``client.experimental.with_raw_response``."""
+
+    def __init__(self, resource: ExperimentalResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def persistent_pty(self) -> ExperimentalPersistentPtyResourceWithRawResponse:
+        """``client.experimental.persistent_pty.with_raw_response``."""
+        return ExperimentalPersistentPtyResourceWithRawResponse(self._resource.persistent_pty)
+
+
+class ExperimentalResourceWithStreamingResponse:
+    """``client.experimental.with_streaming_response``."""
+
+    def __init__(self, resource: ExperimentalResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def persistent_pty(self) -> ExperimentalPersistentPtyResourceWithStreamingResponse:
+        """``client.experimental.persistent_pty.with_streaming_response``."""
+        return ExperimentalPersistentPtyResourceWithStreamingResponse(self._resource.persistent_pty)
+
 
 class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
     """Operations under ``client.experimental.persistent_pty`` (OpenCode ``experimental.persistentPty``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncExperimentalPersistentPtyResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncExperimentalPersistentPtyResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncExperimentalPersistentPtyResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncExperimentalPersistentPtyResourceWithStreamingResponse(self)
+
     async def read(
         self,
         session_id: SessionID,
@@ -534,16 +634,19 @@ class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
 
         ``POST /api/experimental/persistent-pty/shutdown``
         """
-        await self._client.request(
-            RequestOptions(
-                method="POST",
-                path="/api/experimental/persistent-pty/shutdown",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="POST",
+                    path="/api/experimental/persistent-pty/shutdown",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     async def handoff(
@@ -705,16 +808,19 @@ class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
 
         ``DELETE /api/experimental/persistent-pty/:ptyID``
         """
-        await self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="DELETE",
+                    path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     async def connect_token(
@@ -756,6 +862,40 @@ class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
         )
 
 
+class AsyncExperimentalPersistentPtyResourceWithRawResponse:
+    """``client.experimental.persistent_pty.with_raw_response``."""
+
+    def __init__(self, resource: AsyncExperimentalPersistentPtyResource) -> None:
+        self._resource = resource
+        self.read = async_to_raw_response_wrapper(resource.read)
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.create = async_to_raw_response_wrapper(resource.create)
+        self.shutdown = async_to_raw_response_wrapper(resource.shutdown)
+        self.handoff = async_to_raw_response_wrapper(resource.handoff)
+        self.get = async_to_raw_response_wrapper(resource.get)
+        self.update = async_to_raw_response_wrapper(resource.update)
+        self.snapshot = async_to_raw_response_wrapper(resource.snapshot)
+        self.remove = async_to_raw_response_wrapper(resource.remove)
+        self.connect_token = async_to_raw_response_wrapper(resource.connect_token)
+
+
+class AsyncExperimentalPersistentPtyResourceWithStreamingResponse:
+    """``client.experimental.persistent_pty.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncExperimentalPersistentPtyResource) -> None:
+        self._resource = resource
+        self.read = async_to_streamed_response_wrapper(resource.read)
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.create = async_to_streamed_response_wrapper(resource.create)
+        self.shutdown = async_to_streamed_response_wrapper(resource.shutdown)
+        self.handoff = async_to_streamed_response_wrapper(resource.handoff)
+        self.get = async_to_streamed_response_wrapper(resource.get)
+        self.update = async_to_streamed_response_wrapper(resource.update)
+        self.snapshot = async_to_streamed_response_wrapper(resource.snapshot)
+        self.remove = async_to_streamed_response_wrapper(resource.remove)
+        self.connect_token = async_to_streamed_response_wrapper(resource.connect_token)
+
+
 class AsyncExperimentalResource(AsyncAPIResource):
     """Operations under ``client.experimental`` (OpenCode ``experimental``)."""
 
@@ -763,3 +903,37 @@ class AsyncExperimentalResource(AsyncAPIResource):
     def persistent_pty(self) -> AsyncExperimentalPersistentPtyResource:
         """Operations under ``client.experimental.persistent_pty``."""
         return AsyncExperimentalPersistentPtyResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncExperimentalResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncExperimentalResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncExperimentalResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncExperimentalResourceWithStreamingResponse(self)
+
+
+class AsyncExperimentalResourceWithRawResponse:
+    """``client.experimental.with_raw_response``."""
+
+    def __init__(self, resource: AsyncExperimentalResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def persistent_pty(self) -> AsyncExperimentalPersistentPtyResourceWithRawResponse:
+        """``client.experimental.persistent_pty.with_raw_response``."""
+        return AsyncExperimentalPersistentPtyResourceWithRawResponse(self._resource.persistent_pty)
+
+
+class AsyncExperimentalResourceWithStreamingResponse:
+    """``client.experimental.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncExperimentalResource) -> None:
+        self._resource = resource
+
+    @cached_property
+    def persistent_pty(self) -> AsyncExperimentalPersistentPtyResourceWithStreamingResponse:
+        """``client.experimental.persistent_pty.with_streaming_response``."""
+        return AsyncExperimentalPersistentPtyResourceWithStreamingResponse(self._resource.persistent_pty)