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

opencode/resources/shell.py

@@ -6,11 +6,18 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
+from functools import cached_property
 from typing import TYPE_CHECKING, Any, cast
 
 from .._base_client import RequestOptions
 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:
@@ -29,6 +36,16 @@ __all__ = ["ShellResource", "AsyncShellResource"]
 class ShellResource(SyncAPIResource):
     """Operations under ``client.shell`` (OpenCode ``shell``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ShellResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ShellResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ShellResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ShellResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -205,23 +222,60 @@ class ShellResource(SyncAPIResource):
 
         ``DELETE /api/shell/:id``
         """
-        self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/shell/{encode_path_segment(id)}",
-                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=f"/api/shell/{encode_path_segment(id)}",
+                    query={"location": self._location(location)},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class ShellResourceWithRawResponse:
+    """``client.shell.with_raw_response``."""
+
+    def __init__(self, resource: ShellResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.create = to_raw_response_wrapper(resource.create)
+        self.get = to_raw_response_wrapper(resource.get)
+        self.output = to_raw_response_wrapper(resource.output)
+        self.remove = to_raw_response_wrapper(resource.remove)
+
+
+class ShellResourceWithStreamingResponse:
+    """``client.shell.with_streaming_response``."""
+
+    def __init__(self, resource: ShellResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.create = to_streamed_response_wrapper(resource.create)
+        self.get = to_streamed_response_wrapper(resource.get)
+        self.output = to_streamed_response_wrapper(resource.output)
+        self.remove = to_streamed_response_wrapper(resource.remove)
+
+
 class AsyncShellResource(AsyncAPIResource):
     """Operations under ``client.shell`` (OpenCode ``shell``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncShellResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncShellResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncShellResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncShellResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -398,15 +452,42 @@ class AsyncShellResource(AsyncAPIResource):
 
         ``DELETE /api/shell/:id``
         """
-        await self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/shell/{encode_path_segment(id)}",
-                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=f"/api/shell/{encode_path_segment(id)}",
+                    query={"location": self._location(location)},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
+
+
+class AsyncShellResourceWithRawResponse:
+    """``client.shell.with_raw_response``."""
+
+    def __init__(self, resource: AsyncShellResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.create = async_to_raw_response_wrapper(resource.create)
+        self.get = async_to_raw_response_wrapper(resource.get)
+        self.output = async_to_raw_response_wrapper(resource.output)
+        self.remove = async_to_raw_response_wrapper(resource.remove)
+
+
+class AsyncShellResourceWithStreamingResponse:
+    """``client.shell.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncShellResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.create = async_to_streamed_response_wrapper(resource.create)
+        self.get = async_to_streamed_response_wrapper(resource.get)
+        self.output = async_to_streamed_response_wrapper(resource.output)
+        self.remove = async_to_streamed_response_wrapper(resource.remove)

opencode/resources/skill.py

@@ -5,10 +5,17 @@
 
 from __future__ import annotations
 
+from functools import cached_property
 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:
@@ -23,6 +30,16 @@ __all__ = ["SkillResource", "AsyncSkillResource"]
 class SkillResource(SyncAPIResource):
     """Operations under ``client.skill`` (OpenCode ``skill``)."""
 
+    @cached_property
+    def with_raw_response(self) -> SkillResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return SkillResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SkillResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return SkillResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -60,9 +77,35 @@ class SkillResource(SyncAPIResource):
         )
 
 
+class SkillResourceWithRawResponse:
+    """``client.skill.with_raw_response``."""
+
+    def __init__(self, resource: SkillResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+
+
+class SkillResourceWithStreamingResponse:
+    """``client.skill.with_streaming_response``."""
+
+    def __init__(self, resource: SkillResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+
+
 class AsyncSkillResource(AsyncAPIResource):
     """Operations under ``client.skill`` (OpenCode ``skill``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncSkillResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncSkillResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSkillResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncSkillResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -98,3 +141,19 @@ class AsyncSkillResource(AsyncAPIResource):
                 response_type="SkillListResponse",
             ),
         )
+
+
+class AsyncSkillResourceWithRawResponse:
+    """``client.skill.with_raw_response``."""
+
+    def __init__(self, resource: AsyncSkillResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+
+
+class AsyncSkillResourceWithStreamingResponse:
+    """``client.skill.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncSkillResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)

opencode/resources/vcs.py

@@ -10,6 +10,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:
@@ -29,6 +35,16 @@ __all__ = ["VcsResource", "AsyncVcsResource"]
 class VcsBranchResource(SyncAPIResource):
     """Operations under ``client.vcs.branch`` (OpenCode ``vcs.branch``)."""
 
+    @cached_property
+    def with_raw_response(self) -> VcsBranchResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return VcsBranchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VcsBranchResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return VcsBranchResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -68,6 +84,22 @@ class VcsBranchResource(SyncAPIResource):
         )
 
 
+class VcsBranchResourceWithRawResponse:
+    """``client.vcs.branch.with_raw_response``."""
+
+    def __init__(self, resource: VcsBranchResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+
+
+class VcsBranchResourceWithStreamingResponse:
+    """``client.vcs.branch.with_streaming_response``."""
+
+    def __init__(self, resource: VcsBranchResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+
+
 class VcsResource(SyncAPIResource):
     """Operations under ``client.vcs`` (OpenCode ``vcs``)."""
 
@@ -76,6 +108,16 @@ class VcsResource(SyncAPIResource):
         """Operations under ``client.vcs.branch``."""
         return VcsBranchResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> VcsResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return VcsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VcsResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return VcsResourceWithStreamingResponse(self)
+
     def init(
         self,
         *,
@@ -100,17 +142,20 @@ class VcsResource(SyncAPIResource):
 
         ``POST /api/vcs/init``
         """
-        self._client.request(
-            RequestOptions(
-                method="POST",
-                path="/api/vcs/init",
-                query={"location": self._location(location), "provider": provider},
-                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/vcs/init",
+                    query={"location": self._location(location), "provider": provider},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     def get(
@@ -263,9 +308,53 @@ class VcsResource(SyncAPIResource):
         )
 
 
+class VcsResourceWithRawResponse:
+    """``client.vcs.with_raw_response``."""
+
+    def __init__(self, resource: VcsResource) -> None:
+        self._resource = resource
+        self.init = to_raw_response_wrapper(resource.init)
+        self.get = to_raw_response_wrapper(resource.get)
+        self.base = to_raw_response_wrapper(resource.base)
+        self.status = to_raw_response_wrapper(resource.status)
+        self.diff = to_raw_response_wrapper(resource.diff)
+
+    @cached_property
+    def branch(self) -> VcsBranchResourceWithRawResponse:
+        """``client.vcs.branch.with_raw_response``."""
+        return VcsBranchResourceWithRawResponse(self._resource.branch)
+
+
+class VcsResourceWithStreamingResponse:
+    """``client.vcs.with_streaming_response``."""
+
+    def __init__(self, resource: VcsResource) -> None:
+        self._resource = resource
+        self.init = to_streamed_response_wrapper(resource.init)
+        self.get = to_streamed_response_wrapper(resource.get)
+        self.base = to_streamed_response_wrapper(resource.base)
+        self.status = to_streamed_response_wrapper(resource.status)
+        self.diff = to_streamed_response_wrapper(resource.diff)
+
+    @cached_property
+    def branch(self) -> VcsBranchResourceWithStreamingResponse:
+        """``client.vcs.branch.with_streaming_response``."""
+        return VcsBranchResourceWithStreamingResponse(self._resource.branch)
+
+
 class AsyncVcsBranchResource(AsyncAPIResource):
     """Operations under ``client.vcs.branch`` (OpenCode ``vcs.branch``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncVcsBranchResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncVcsBranchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVcsBranchResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncVcsBranchResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -305,6 +394,22 @@ class AsyncVcsBranchResource(AsyncAPIResource):
         )
 
 
+class AsyncVcsBranchResourceWithRawResponse:
+    """``client.vcs.branch.with_raw_response``."""
+
+    def __init__(self, resource: AsyncVcsBranchResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+
+
+class AsyncVcsBranchResourceWithStreamingResponse:
+    """``client.vcs.branch.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncVcsBranchResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+
+
 class AsyncVcsResource(AsyncAPIResource):
     """Operations under ``client.vcs`` (OpenCode ``vcs``)."""
 
@@ -313,6 +418,16 @@ class AsyncVcsResource(AsyncAPIResource):
         """Operations under ``client.vcs.branch``."""
         return AsyncVcsBranchResource(self._client)
 
+    @cached_property
+    def with_raw_response(self) -> AsyncVcsResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncVcsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVcsResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncVcsResourceWithStreamingResponse(self)
+
     async def init(
         self,
         *,
@@ -337,17 +452,20 @@ class AsyncVcsResource(AsyncAPIResource):
 
         ``POST /api/vcs/init``
         """
-        await self._client.request(
-            RequestOptions(
-                method="POST",
-                path="/api/vcs/init",
-                query={"location": self._location(location), "provider": provider},
-                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/vcs/init",
+                    query={"location": self._location(location), "provider": provider},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     async def get(
@@ -498,3 +616,37 @@ class AsyncVcsResource(AsyncAPIResource):
                 response_type="VcsDiffResponse",
             ),
         )
+
+
+class AsyncVcsResourceWithRawResponse:
+    """``client.vcs.with_raw_response``."""
+
+    def __init__(self, resource: AsyncVcsResource) -> None:
+        self._resource = resource
+        self.init = async_to_raw_response_wrapper(resource.init)
+        self.get = async_to_raw_response_wrapper(resource.get)
+        self.base = async_to_raw_response_wrapper(resource.base)
+        self.status = async_to_raw_response_wrapper(resource.status)
+        self.diff = async_to_raw_response_wrapper(resource.diff)
+
+    @cached_property
+    def branch(self) -> AsyncVcsBranchResourceWithRawResponse:
+        """``client.vcs.branch.with_raw_response``."""
+        return AsyncVcsBranchResourceWithRawResponse(self._resource.branch)
+
+
+class AsyncVcsResourceWithStreamingResponse:
+    """``client.vcs.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncVcsResource) -> None:
+        self._resource = resource
+        self.init = async_to_streamed_response_wrapper(resource.init)
+        self.get = async_to_streamed_response_wrapper(resource.get)
+        self.base = async_to_streamed_response_wrapper(resource.base)
+        self.status = async_to_streamed_response_wrapper(resource.status)
+        self.diff = async_to_streamed_response_wrapper(resource.diff)
+
+    @cached_property
+    def branch(self) -> AsyncVcsBranchResourceWithStreamingResponse:
+        """``client.vcs.branch.with_streaming_response``."""
+        return AsyncVcsBranchResourceWithStreamingResponse(self._resource.branch)

opencode/resources/voice.py

@@ -6,10 +6,17 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
+from functools import cached_property
 from typing import TYPE_CHECKING, Any, 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:
@@ -24,6 +31,16 @@ __all__ = ["VoiceResource", "AsyncVoiceResource"]
 class VoiceResource(SyncAPIResource):
     """Operations under ``client.voice`` (OpenCode ``voice``)."""
 
+    @cached_property
+    def with_raw_response(self) -> VoiceResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return VoiceResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> VoiceResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return VoiceResourceWithStreamingResponse(self)
+
     def session(
         self,
         *,
@@ -67,9 +84,35 @@ class VoiceResource(SyncAPIResource):
         )
 
 
+class VoiceResourceWithRawResponse:
+    """``client.voice.with_raw_response``."""
+
+    def __init__(self, resource: VoiceResource) -> None:
+        self._resource = resource
+        self.session = to_raw_response_wrapper(resource.session)
+
+
+class VoiceResourceWithStreamingResponse:
+    """``client.voice.with_streaming_response``."""
+
+    def __init__(self, resource: VoiceResource) -> None:
+        self._resource = resource
+        self.session = to_streamed_response_wrapper(resource.session)
+
+
 class AsyncVoiceResource(AsyncAPIResource):
     """Operations under ``client.voice`` (OpenCode ``voice``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncVoiceResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncVoiceResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncVoiceResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncVoiceResourceWithStreamingResponse(self)
+
     async def session(
         self,
         *,
@@ -111,3 +154,19 @@ class AsyncVoiceResource(AsyncAPIResource):
                 unwrap=True,
             ),
         )
+
+
+class AsyncVoiceResourceWithRawResponse:
+    """``client.voice.with_raw_response``."""
+
+    def __init__(self, resource: AsyncVoiceResource) -> None:
+        self._resource = resource
+        self.session = async_to_raw_response_wrapper(resource.session)
+
+
+class AsyncVoiceResourceWithStreamingResponse:
+    """``client.voice.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncVoiceResource) -> None:
+        self._resource = resource
+        self.session = async_to_streamed_response_wrapper(resource.session)