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

opencode/resources/agent.py

@@ -5,11 +5,18 @@
 
 from __future__ import annotations
 
+from functools import cached_property
 from typing import TYPE_CHECKING, 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:
@@ -26,6 +33,16 @@ __all__ = ["AgentResource", "AsyncAgentResource"]
 class AgentResource(SyncAPIResource):
     """Operations under ``client.agent`` (OpenCode ``agent``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AgentResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AgentResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AgentResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AgentResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -101,9 +118,37 @@ class AgentResource(SyncAPIResource):
         )
 
 
+class AgentResourceWithRawResponse:
+    """``client.agent.with_raw_response``."""
+
+    def __init__(self, resource: AgentResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.get = to_raw_response_wrapper(resource.get)
+
+
+class AgentResourceWithStreamingResponse:
+    """``client.agent.with_streaming_response``."""
+
+    def __init__(self, resource: AgentResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.get = to_streamed_response_wrapper(resource.get)
+
+
 class AsyncAgentResource(AsyncAPIResource):
     """Operations under ``client.agent`` (OpenCode ``agent``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncAgentResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncAgentResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAgentResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncAgentResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -177,3 +222,21 @@ class AsyncAgentResource(AsyncAPIResource):
                 response_type="AgentGetResponse",
             ),
         )
+
+
+class AsyncAgentResourceWithRawResponse:
+    """``client.agent.with_raw_response``."""
+
+    def __init__(self, resource: AsyncAgentResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.get = async_to_raw_response_wrapper(resource.get)
+
+
+class AsyncAgentResourceWithStreamingResponse:
+    """``client.agent.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncAgentResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.get = async_to_streamed_response_wrapper(resource.get)

opencode/resources/command.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__ = ["CommandResource", "AsyncCommandResource"]
 class CommandResource(SyncAPIResource):
     """Operations under ``client.command`` (OpenCode ``command``)."""
 
+    @cached_property
+    def with_raw_response(self) -> CommandResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return CommandResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CommandResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return CommandResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -60,9 +77,35 @@ class CommandResource(SyncAPIResource):
         )
 
 
+class CommandResourceWithRawResponse:
+    """``client.command.with_raw_response``."""
+
+    def __init__(self, resource: CommandResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+
+
+class CommandResourceWithStreamingResponse:
+    """``client.command.with_streaming_response``."""
+
+    def __init__(self, resource: CommandResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+
+
 class AsyncCommandResource(AsyncAPIResource):
     """Operations under ``client.command`` (OpenCode ``command``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncCommandResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncCommandResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCommandResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncCommandResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -98,3 +141,19 @@ class AsyncCommandResource(AsyncAPIResource):
                 response_type="CommandListResponse",
             ),
         )
+
+
+class AsyncCommandResourceWithRawResponse:
+    """``client.command.with_raw_response``."""
+
+    def __init__(self, resource: AsyncCommandResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+
+
+class AsyncCommandResourceWithStreamingResponse:
+    """``client.command.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncCommandResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)

opencode/resources/config.py

@@ -6,10 +6,17 @@
 from __future__ import annotations
 
 import builtins
+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:
@@ -25,6 +32,16 @@ __all__ = ["ConfigResource", "AsyncConfigResource"]
 class ConfigResource(SyncAPIResource):
     """Operations under ``client.config`` (OpenCode ``config``)."""
 
+    @cached_property
+    def with_raw_response(self) -> ConfigResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return ConfigResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ConfigResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return ConfigResourceWithStreamingResponse(self)
+
     def get(
         self,
         *,
@@ -117,23 +134,56 @@ class ConfigResource(SyncAPIResource):
 
         ``PATCH /api/experimental/config``
         """
-        self._client.request(
-            RequestOptions(
-                method="PATCH",
-                path="/api/experimental/config",
-                body={"shell": shell},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="PATCH",
+                    path="/api/experimental/config",
+                    body={"shell": shell},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class ConfigResourceWithRawResponse:
+    """``client.config.with_raw_response``."""
+
+    def __init__(self, resource: ConfigResource) -> None:
+        self._resource = resource
+        self.get = to_raw_response_wrapper(resource.get)
+        self.shells = to_raw_response_wrapper(resource.shells)
+        self.update = to_raw_response_wrapper(resource.update)
+
+
+class ConfigResourceWithStreamingResponse:
+    """``client.config.with_streaming_response``."""
+
+    def __init__(self, resource: ConfigResource) -> None:
+        self._resource = resource
+        self.get = to_streamed_response_wrapper(resource.get)
+        self.shells = to_streamed_response_wrapper(resource.shells)
+        self.update = to_streamed_response_wrapper(resource.update)
+
+
 class AsyncConfigResource(AsyncAPIResource):
     """Operations under ``client.config`` (OpenCode ``config``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncConfigResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncConfigResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncConfigResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncConfigResourceWithStreamingResponse(self)
+
     async def get(
         self,
         *,
@@ -226,15 +276,38 @@ class AsyncConfigResource(AsyncAPIResource):
 
         ``PATCH /api/experimental/config``
         """
-        await self._client.request(
-            RequestOptions(
-                method="PATCH",
-                path="/api/experimental/config",
-                body={"shell": shell},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="PATCH",
+                    path="/api/experimental/config",
+                    body={"shell": shell},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
+
+
+class AsyncConfigResourceWithRawResponse:
+    """``client.config.with_raw_response``."""
+
+    def __init__(self, resource: AsyncConfigResource) -> None:
+        self._resource = resource
+        self.get = async_to_raw_response_wrapper(resource.get)
+        self.shells = async_to_raw_response_wrapper(resource.shells)
+        self.update = async_to_raw_response_wrapper(resource.update)
+
+
+class AsyncConfigResourceWithStreamingResponse:
+    """``client.config.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncConfigResource) -> None:
+        self._resource = resource
+        self.get = async_to_streamed_response_wrapper(resource.get)
+        self.shells = async_to_streamed_response_wrapper(resource.shells)
+        self.update = async_to_streamed_response_wrapper(resource.update)

opencode/resources/credential.py

@@ -6,11 +6,18 @@
 from __future__ import annotations
 
 import builtins
+from functools import cached_property
 from typing import TYPE_CHECKING, 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:
@@ -27,6 +34,16 @@ __all__ = ["CredentialResource", "AsyncCredentialResource"]
 class CredentialResource(SyncAPIResource):
     """Operations under ``client.credential`` (OpenCode ``credential``)."""
 
+    @cached_property
+    def with_raw_response(self) -> CredentialResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return CredentialResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CredentialResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return CredentialResourceWithStreamingResponse(self)
+
     def list(
         self,
         *,
@@ -128,17 +145,20 @@ class CredentialResource(SyncAPIResource):
 
         ``PATCH /api/credential/:credentialID``
         """
-        self._client.request(
-            RequestOptions(
-                method="PATCH",
-                path=f"/api/credential/{encode_path_segment(credential_id)}",
-                body={"label": label},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="PATCH",
+                    path=f"/api/credential/{encode_path_segment(credential_id)}",
+                    body={"label": label},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     def activate(
@@ -160,16 +180,19 @@ class CredentialResource(SyncAPIResource):
 
         ``POST /api/credential/:credentialID/activate``
         """
-        self._client.request(
-            RequestOptions(
-                method="POST",
-                path=f"/api/credential/{encode_path_segment(credential_id)}/activate",
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            self._client.request(
+                RequestOptions(
+                    method="POST",
+                    path=f"/api/credential/{encode_path_segment(credential_id)}/activate",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     def remove(
@@ -191,22 +214,59 @@ class CredentialResource(SyncAPIResource):
 
         ``DELETE /api/credential/:credentialID``
         """
-        self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/credential/{encode_path_segment(credential_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/credential/{encode_path_segment(credential_id)}",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
 
+class CredentialResourceWithRawResponse:
+    """``client.credential.with_raw_response``."""
+
+    def __init__(self, resource: CredentialResource) -> None:
+        self._resource = resource
+        self.list = to_raw_response_wrapper(resource.list)
+        self.create = to_raw_response_wrapper(resource.create)
+        self.update = to_raw_response_wrapper(resource.update)
+        self.activate = to_raw_response_wrapper(resource.activate)
+        self.remove = to_raw_response_wrapper(resource.remove)
+
+
+class CredentialResourceWithStreamingResponse:
+    """``client.credential.with_streaming_response``."""
+
+    def __init__(self, resource: CredentialResource) -> None:
+        self._resource = resource
+        self.list = to_streamed_response_wrapper(resource.list)
+        self.create = to_streamed_response_wrapper(resource.create)
+        self.update = to_streamed_response_wrapper(resource.update)
+        self.activate = to_streamed_response_wrapper(resource.activate)
+        self.remove = to_streamed_response_wrapper(resource.remove)
+
+
 class AsyncCredentialResource(AsyncAPIResource):
     """Operations under ``client.credential`` (OpenCode ``credential``)."""
 
+    @cached_property
+    def with_raw_response(self) -> AsyncCredentialResourceWithRawResponse:
+        """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value."""
+        return AsyncCredentialResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCredentialResourceWithStreamingResponse:
+        """Same methods, returning a context manager over the HTTP response without reading the body."""
+        return AsyncCredentialResourceWithStreamingResponse(self)
+
     async def list(
         self,
         *,
@@ -308,17 +368,20 @@ class AsyncCredentialResource(AsyncAPIResource):
 
         ``PATCH /api/credential/:credentialID``
         """
-        await self._client.request(
-            RequestOptions(
-                method="PATCH",
-                path=f"/api/credential/{encode_path_segment(credential_id)}",
-                body={"label": label},
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
+        return cast(
+            "None",
+            await self._client.request(
+                RequestOptions(
+                    method="PATCH",
+                    path=f"/api/credential/{encode_path_segment(credential_id)}",
+                    body={"label": label},
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     async def activate(
@@ -340,16 +403,19 @@ class AsyncCredentialResource(AsyncAPIResource):
 
         ``POST /api/credential/:credentialID/activate``
         """
-        await self._client.request(
-            RequestOptions(
-                method="POST",
-                path=f"/api/credential/{encode_path_segment(credential_id)}/activate",
-                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=f"/api/credential/{encode_path_segment(credential_id)}/activate",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
 
     async def remove(
@@ -371,14 +437,41 @@ class AsyncCredentialResource(AsyncAPIResource):
 
         ``DELETE /api/credential/:credentialID``
         """
-        await self._client.request(
-            RequestOptions(
-                method="DELETE",
-                path=f"/api/credential/{encode_path_segment(credential_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/credential/{encode_path_segment(credential_id)}",
+                    extra_headers=extra_headers,
+                    extra_query=extra_query,
+                    extra_body=extra_body,
+                    timeout=timeout,
+                ),
+                kind="void",
             ),
-            kind="void",
         )
+
+
+class AsyncCredentialResourceWithRawResponse:
+    """``client.credential.with_raw_response``."""
+
+    def __init__(self, resource: AsyncCredentialResource) -> None:
+        self._resource = resource
+        self.list = async_to_raw_response_wrapper(resource.list)
+        self.create = async_to_raw_response_wrapper(resource.create)
+        self.update = async_to_raw_response_wrapper(resource.update)
+        self.activate = async_to_raw_response_wrapper(resource.activate)
+        self.remove = async_to_raw_response_wrapper(resource.remove)
+
+
+class AsyncCredentialResourceWithStreamingResponse:
+    """``client.credential.with_streaming_response``."""
+
+    def __init__(self, resource: AsyncCredentialResource) -> None:
+        self._resource = resource
+        self.list = async_to_streamed_response_wrapper(resource.list)
+        self.create = async_to_streamed_response_wrapper(resource.create)
+        self.update = async_to_streamed_response_wrapper(resource.update)
+        self.activate = async_to_streamed_response_wrapper(resource.activate)
+        self.remove = async_to_streamed_response_wrapper(resource.remove)