feat(api): manual updates

src/opencode_ai/resources/__init__.py

@@ -0,0 +1,159 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .app import (
+    AppResource,
+    AsyncAppResource,
+    AppResourceWithRawResponse,
+    AsyncAppResourceWithRawResponse,
+    AppResourceWithStreamingResponse,
+    AsyncAppResourceWithStreamingResponse,
+)
+from .tui import (
+    TuiResource,
+    AsyncTuiResource,
+    TuiResourceWithRawResponse,
+    AsyncTuiResourceWithRawResponse,
+    TuiResourceWithStreamingResponse,
+    AsyncTuiResourceWithStreamingResponse,
+)
+from .file import (
+    FileResource,
+    AsyncFileResource,
+    FileResourceWithRawResponse,
+    AsyncFileResourceWithRawResponse,
+    FileResourceWithStreamingResponse,
+    AsyncFileResourceWithStreamingResponse,
+)
+from .find import (
+    FindResource,
+    AsyncFindResource,
+    FindResourceWithRawResponse,
+    AsyncFindResourceWithRawResponse,
+    FindResourceWithStreamingResponse,
+    AsyncFindResourceWithStreamingResponse,
+)
+from .path import (
+    PathResource,
+    AsyncPathResource,
+    PathResourceWithRawResponse,
+    AsyncPathResourceWithRawResponse,
+    PathResourceWithStreamingResponse,
+    AsyncPathResourceWithStreamingResponse,
+)
+from .agent import (
+    AgentResource,
+    AsyncAgentResource,
+    AgentResourceWithRawResponse,
+    AsyncAgentResourceWithRawResponse,
+    AgentResourceWithStreamingResponse,
+    AsyncAgentResourceWithStreamingResponse,
+)
+from .event import (
+    EventResource,
+    AsyncEventResource,
+    EventResourceWithRawResponse,
+    AsyncEventResourceWithRawResponse,
+    EventResourceWithStreamingResponse,
+    AsyncEventResourceWithStreamingResponse,
+)
+from .config import (
+    ConfigResource,
+    AsyncConfigResource,
+    ConfigResourceWithRawResponse,
+    AsyncConfigResourceWithRawResponse,
+    ConfigResourceWithStreamingResponse,
+    AsyncConfigResourceWithStreamingResponse,
+)
+from .command import (
+    CommandResource,
+    AsyncCommandResource,
+    CommandResourceWithRawResponse,
+    AsyncCommandResourceWithRawResponse,
+    CommandResourceWithStreamingResponse,
+    AsyncCommandResourceWithStreamingResponse,
+)
+from .project import (
+    ProjectResource,
+    AsyncProjectResource,
+    ProjectResourceWithRawResponse,
+    AsyncProjectResourceWithRawResponse,
+    ProjectResourceWithStreamingResponse,
+    AsyncProjectResourceWithStreamingResponse,
+)
+from .session import (
+    SessionResource,
+    AsyncSessionResource,
+    SessionResourceWithRawResponse,
+    AsyncSessionResourceWithRawResponse,
+    SessionResourceWithStreamingResponse,
+    AsyncSessionResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "EventResource",
+    "AsyncEventResource",
+    "EventResourceWithRawResponse",
+    "AsyncEventResourceWithRawResponse",
+    "EventResourceWithStreamingResponse",
+    "AsyncEventResourceWithStreamingResponse",
+    "PathResource",
+    "AsyncPathResource",
+    "PathResourceWithRawResponse",
+    "AsyncPathResourceWithRawResponse",
+    "PathResourceWithStreamingResponse",
+    "AsyncPathResourceWithStreamingResponse",
+    "AppResource",
+    "AsyncAppResource",
+    "AppResourceWithRawResponse",
+    "AsyncAppResourceWithRawResponse",
+    "AppResourceWithStreamingResponse",
+    "AsyncAppResourceWithStreamingResponse",
+    "AgentResource",
+    "AsyncAgentResource",
+    "AgentResourceWithRawResponse",
+    "AsyncAgentResourceWithRawResponse",
+    "AgentResourceWithStreamingResponse",
+    "AsyncAgentResourceWithStreamingResponse",
+    "FindResource",
+    "AsyncFindResource",
+    "FindResourceWithRawResponse",
+    "AsyncFindResourceWithRawResponse",
+    "FindResourceWithStreamingResponse",
+    "AsyncFindResourceWithStreamingResponse",
+    "FileResource",
+    "AsyncFileResource",
+    "FileResourceWithRawResponse",
+    "AsyncFileResourceWithRawResponse",
+    "FileResourceWithStreamingResponse",
+    "AsyncFileResourceWithStreamingResponse",
+    "ConfigResource",
+    "AsyncConfigResource",
+    "ConfigResourceWithRawResponse",
+    "AsyncConfigResourceWithRawResponse",
+    "ConfigResourceWithStreamingResponse",
+    "AsyncConfigResourceWithStreamingResponse",
+    "CommandResource",
+    "AsyncCommandResource",
+    "CommandResourceWithRawResponse",
+    "AsyncCommandResourceWithRawResponse",
+    "CommandResourceWithStreamingResponse",
+    "AsyncCommandResourceWithStreamingResponse",
+    "ProjectResource",
+    "AsyncProjectResource",
+    "ProjectResourceWithRawResponse",
+    "AsyncProjectResourceWithRawResponse",
+    "ProjectResourceWithStreamingResponse",
+    "AsyncProjectResourceWithStreamingResponse",
+    "SessionResource",
+    "AsyncSessionResource",
+    "SessionResourceWithRawResponse",
+    "AsyncSessionResourceWithRawResponse",
+    "SessionResourceWithStreamingResponse",
+    "AsyncSessionResourceWithStreamingResponse",
+    "TuiResource",
+    "AsyncTuiResource",
+    "TuiResourceWithRawResponse",
+    "AsyncTuiResourceWithRawResponse",
+    "TuiResourceWithStreamingResponse",
+    "AsyncTuiResourceWithStreamingResponse",
+]

src/opencode_ai/resources/agent.py

@@ -0,0 +1,169 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import agent_list_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.agent_list_response import AgentListResponse
+
+__all__ = ["AgentResource", "AsyncAgentResource"]
+
+
+class AgentResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AgentResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AgentResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AgentResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AgentResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AgentListResponse:
+        """
+        List all agents
+
+        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
+        """
+        return self._get(
+            "/agent",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, agent_list_params.AgentListParams),
+            ),
+            cast_to=AgentListResponse,
+        )
+
+
+class AsyncAgentResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncAgentResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAgentResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAgentResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncAgentResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AgentListResponse:
+        """
+        List all agents
+
+        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
+        """
+        return await self._get(
+            "/agent",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, agent_list_params.AgentListParams),
+            ),
+            cast_to=AgentListResponse,
+        )
+
+
+class AgentResourceWithRawResponse:
+    def __init__(self, agent: AgentResource) -> None:
+        self._agent = agent
+
+        self.list = to_raw_response_wrapper(
+            agent.list,
+        )
+
+
+class AsyncAgentResourceWithRawResponse:
+    def __init__(self, agent: AsyncAgentResource) -> None:
+        self._agent = agent
+
+        self.list = async_to_raw_response_wrapper(
+            agent.list,
+        )
+
+
+class AgentResourceWithStreamingResponse:
+    def __init__(self, agent: AgentResource) -> None:
+        self._agent = agent
+
+        self.list = to_streamed_response_wrapper(
+            agent.list,
+        )
+
+
+class AsyncAgentResourceWithStreamingResponse:
+    def __init__(self, agent: AsyncAgentResource) -> None:
+        self._agent = agent
+
+        self.list = async_to_streamed_response_wrapper(
+            agent.list,
+        )

src/opencode_ai/resources/app.py

@@ -0,0 +1,297 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import app_log_params, app_providers_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.app_log_response import AppLogResponse
+from ..types.app_providers_response import AppProvidersResponse
+
+__all__ = ["AppResource", "AsyncAppResource"]
+
+
+class AppResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AppResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AppResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AppResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AppResourceWithStreamingResponse(self)
+
+    def log(
+        self,
+        *,
+        level: Literal["debug", "info", "error", "warn"],
+        message: str,
+        service: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        extra: Dict[str, object] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AppLogResponse:
+        """
+        Write a log entry to the server logs
+
+        Args:
+          level: Log level
+
+          message: Log message
+
+          service: Service name for the log entry
+
+          extra: Additional metadata for the log entry
+
+          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(
+            "/log",
+            body=maybe_transform(
+                {
+                    "level": level,
+                    "message": message,
+                    "service": service,
+                    "extra": extra,
+                },
+                app_log_params.AppLogParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, app_log_params.AppLogParams),
+            ),
+            cast_to=AppLogResponse,
+        )
+
+    def providers(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AppProvidersResponse:
+        """
+        List all providers
+
+        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
+        """
+        return self._get(
+            "/config/providers",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, app_providers_params.AppProvidersParams),
+            ),
+            cast_to=AppProvidersResponse,
+        )
+
+
+class AsyncAppResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncAppResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncAppResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncAppResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncAppResourceWithStreamingResponse(self)
+
+    async def log(
+        self,
+        *,
+        level: Literal["debug", "info", "error", "warn"],
+        message: str,
+        service: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        extra: Dict[str, object] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AppLogResponse:
+        """
+        Write a log entry to the server logs
+
+        Args:
+          level: Log level
+
+          message: Log message
+
+          service: Service name for the log entry
+
+          extra: Additional metadata for the log entry
+
+          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(
+            "/log",
+            body=await async_maybe_transform(
+                {
+                    "level": level,
+                    "message": message,
+                    "service": service,
+                    "extra": extra,
+                },
+                app_log_params.AppLogParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, app_log_params.AppLogParams),
+            ),
+            cast_to=AppLogResponse,
+        )
+
+    async def providers(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AppProvidersResponse:
+        """
+        List all providers
+
+        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
+        """
+        return await self._get(
+            "/config/providers",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, app_providers_params.AppProvidersParams),
+            ),
+            cast_to=AppProvidersResponse,
+        )
+
+
+class AppResourceWithRawResponse:
+    def __init__(self, app: AppResource) -> None:
+        self._app = app
+
+        self.log = to_raw_response_wrapper(
+            app.log,
+        )
+        self.providers = to_raw_response_wrapper(
+            app.providers,
+        )
+
+
+class AsyncAppResourceWithRawResponse:
+    def __init__(self, app: AsyncAppResource) -> None:
+        self._app = app
+
+        self.log = async_to_raw_response_wrapper(
+            app.log,
+        )
+        self.providers = async_to_raw_response_wrapper(
+            app.providers,
+        )
+
+
+class AppResourceWithStreamingResponse:
+    def __init__(self, app: AppResource) -> None:
+        self._app = app
+
+        self.log = to_streamed_response_wrapper(
+            app.log,
+        )
+        self.providers = to_streamed_response_wrapper(
+            app.providers,
+        )
+
+
+class AsyncAppResourceWithStreamingResponse:
+    def __init__(self, app: AsyncAppResource) -> None:
+        self._app = app
+
+        self.log = async_to_streamed_response_wrapper(
+            app.log,
+        )
+        self.providers = async_to_streamed_response_wrapper(
+            app.providers,
+        )

src/opencode_ai/resources/command.py

@@ -0,0 +1,169 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import command_list_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.command_list_response import CommandListResponse
+
+__all__ = ["CommandResource", "AsyncCommandResource"]
+
+
+class CommandResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CommandResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return CommandResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CommandResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return CommandResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> CommandListResponse:
+        """
+        List all commands
+
+        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
+        """
+        return self._get(
+            "/command",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, command_list_params.CommandListParams),
+            ),
+            cast_to=CommandListResponse,
+        )
+
+
+class AsyncCommandResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCommandResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCommandResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCommandResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncCommandResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> CommandListResponse:
+        """
+        List all commands
+
+        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
+        """
+        return await self._get(
+            "/command",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, command_list_params.CommandListParams),
+            ),
+            cast_to=CommandListResponse,
+        )
+
+
+class CommandResourceWithRawResponse:
+    def __init__(self, command: CommandResource) -> None:
+        self._command = command
+
+        self.list = to_raw_response_wrapper(
+            command.list,
+        )
+
+
+class AsyncCommandResourceWithRawResponse:
+    def __init__(self, command: AsyncCommandResource) -> None:
+        self._command = command
+
+        self.list = async_to_raw_response_wrapper(
+            command.list,
+        )
+
+
+class CommandResourceWithStreamingResponse:
+    def __init__(self, command: CommandResource) -> None:
+        self._command = command
+
+        self.list = to_streamed_response_wrapper(
+            command.list,
+        )
+
+
+class AsyncCommandResourceWithStreamingResponse:
+    def __init__(self, command: AsyncCommandResource) -> None:
+        self._command = command
+
+        self.list = async_to_streamed_response_wrapper(
+            command.list,
+        )

src/opencode_ai/resources/config.py

@@ -0,0 +1,169 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import config_get_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.config import Config
+
+__all__ = ["ConfigResource", "AsyncConfigResource"]
+
+
+class ConfigResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ConfigResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return ConfigResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ConfigResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return ConfigResourceWithStreamingResponse(self)
+
+    def get(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Config:
+        """
+        Get config info
+
+        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
+        """
+        return self._get(
+            "/config",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, config_get_params.ConfigGetParams),
+            ),
+            cast_to=Config,
+        )
+
+
+class AsyncConfigResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncConfigResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncConfigResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncConfigResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncConfigResourceWithStreamingResponse(self)
+
+    async def get(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Config:
+        """
+        Get config info
+
+        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
+        """
+        return await self._get(
+            "/config",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, config_get_params.ConfigGetParams),
+            ),
+            cast_to=Config,
+        )
+
+
+class ConfigResourceWithRawResponse:
+    def __init__(self, config: ConfigResource) -> None:
+        self._config = config
+
+        self.get = to_raw_response_wrapper(
+            config.get,
+        )
+
+
+class AsyncConfigResourceWithRawResponse:
+    def __init__(self, config: AsyncConfigResource) -> None:
+        self._config = config
+
+        self.get = async_to_raw_response_wrapper(
+            config.get,
+        )
+
+
+class ConfigResourceWithStreamingResponse:
+    def __init__(self, config: ConfigResource) -> None:
+        self._config = config
+
+        self.get = to_streamed_response_wrapper(
+            config.get,
+        )
+
+
+class AsyncConfigResourceWithStreamingResponse:
+    def __init__(self, config: AsyncConfigResource) -> None:
+        self._config = config
+
+        self.get = async_to_streamed_response_wrapper(
+            config.get,
+        )

src/opencode_ai/resources/event.py

@@ -0,0 +1,178 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import httpx
+
+from ..types import event_list_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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 .._streaming import Stream, AsyncStream
+from .._base_client import make_request_options
+from ..types.event_list_response import EventListResponse
+
+__all__ = ["EventResource", "AsyncEventResource"]
+
+
+class EventResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> EventResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return EventResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> EventResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return EventResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Stream[EventListResponse]:
+        """
+        Get events
+
+        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
+        """
+        extra_headers = {"Accept": "text/event-stream", **(extra_headers or {})}
+        return self._get(
+            "/event",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, event_list_params.EventListParams),
+            ),
+            cast_to=cast(Any, EventListResponse),  # Union types cannot be passed in as arguments in the type system
+            stream=True,
+            stream_cls=Stream[EventListResponse],
+        )
+
+
+class AsyncEventResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncEventResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncEventResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncEventResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncEventResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> AsyncStream[EventListResponse]:
+        """
+        Get events
+
+        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
+        """
+        extra_headers = {"Accept": "text/event-stream", **(extra_headers or {})}
+        return await self._get(
+            "/event",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, event_list_params.EventListParams),
+            ),
+            cast_to=cast(Any, EventListResponse),  # Union types cannot be passed in as arguments in the type system
+            stream=True,
+            stream_cls=AsyncStream[EventListResponse],
+        )
+
+
+class EventResourceWithRawResponse:
+    def __init__(self, event: EventResource) -> None:
+        self._event = event
+
+        self.list = to_raw_response_wrapper(
+            event.list,
+        )
+
+
+class AsyncEventResourceWithRawResponse:
+    def __init__(self, event: AsyncEventResource) -> None:
+        self._event = event
+
+        self.list = async_to_raw_response_wrapper(
+            event.list,
+        )
+
+
+class EventResourceWithStreamingResponse:
+    def __init__(self, event: EventResource) -> None:
+        self._event = event
+
+        self.list = to_streamed_response_wrapper(
+            event.list,
+        )
+
+
+class AsyncEventResourceWithStreamingResponse:
+    def __init__(self, event: AsyncEventResource) -> None:
+        self._event = event
+
+        self.list = async_to_streamed_response_wrapper(
+            event.list,
+        )

src/opencode_ai/resources/file.py

@@ -0,0 +1,363 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import file_list_params, file_read_params, file_status_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.file_list_response import FileListResponse
+from ..types.file_read_response import FileReadResponse
+from ..types.file_status_response import FileStatusResponse
+
+__all__ = ["FileResource", "AsyncFileResource"]
+
+
+class FileResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FileResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return FileResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FileResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return FileResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        path: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FileListResponse:
+        """
+        List files and directories
+
+        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
+        """
+        return self._get(
+            "/file",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "path": path,
+                        "directory": directory,
+                    },
+                    file_list_params.FileListParams,
+                ),
+            ),
+            cast_to=FileListResponse,
+        )
+
+    def read(
+        self,
+        *,
+        path: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FileReadResponse:
+        """
+        Read a file
+
+        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
+        """
+        return self._get(
+            "/file/content",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "path": path,
+                        "directory": directory,
+                    },
+                    file_read_params.FileReadParams,
+                ),
+            ),
+            cast_to=FileReadResponse,
+        )
+
+    def status(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FileStatusResponse:
+        """
+        Get file status
+
+        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
+        """
+        return self._get(
+            "/file/status",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, file_status_params.FileStatusParams),
+            ),
+            cast_to=FileStatusResponse,
+        )
+
+
+class AsyncFileResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFileResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFileResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFileResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncFileResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        path: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FileListResponse:
+        """
+        List files and directories
+
+        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
+        """
+        return await self._get(
+            "/file",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "path": path,
+                        "directory": directory,
+                    },
+                    file_list_params.FileListParams,
+                ),
+            ),
+            cast_to=FileListResponse,
+        )
+
+    async def read(
+        self,
+        *,
+        path: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FileReadResponse:
+        """
+        Read a file
+
+        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
+        """
+        return await self._get(
+            "/file/content",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "path": path,
+                        "directory": directory,
+                    },
+                    file_read_params.FileReadParams,
+                ),
+            ),
+            cast_to=FileReadResponse,
+        )
+
+    async def status(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FileStatusResponse:
+        """
+        Get file status
+
+        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
+        """
+        return await self._get(
+            "/file/status",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, file_status_params.FileStatusParams),
+            ),
+            cast_to=FileStatusResponse,
+        )
+
+
+class FileResourceWithRawResponse:
+    def __init__(self, file: FileResource) -> None:
+        self._file = file
+
+        self.list = to_raw_response_wrapper(
+            file.list,
+        )
+        self.read = to_raw_response_wrapper(
+            file.read,
+        )
+        self.status = to_raw_response_wrapper(
+            file.status,
+        )
+
+
+class AsyncFileResourceWithRawResponse:
+    def __init__(self, file: AsyncFileResource) -> None:
+        self._file = file
+
+        self.list = async_to_raw_response_wrapper(
+            file.list,
+        )
+        self.read = async_to_raw_response_wrapper(
+            file.read,
+        )
+        self.status = async_to_raw_response_wrapper(
+            file.status,
+        )
+
+
+class FileResourceWithStreamingResponse:
+    def __init__(self, file: FileResource) -> None:
+        self._file = file
+
+        self.list = to_streamed_response_wrapper(
+            file.list,
+        )
+        self.read = to_streamed_response_wrapper(
+            file.read,
+        )
+        self.status = to_streamed_response_wrapper(
+            file.status,
+        )
+
+
+class AsyncFileResourceWithStreamingResponse:
+    def __init__(self, file: AsyncFileResource) -> None:
+        self._file = file
+
+        self.list = async_to_streamed_response_wrapper(
+            file.list,
+        )
+        self.read = async_to_streamed_response_wrapper(
+            file.read,
+        )
+        self.status = async_to_streamed_response_wrapper(
+            file.status,
+        )

src/opencode_ai/resources/find.py

@@ -0,0 +1,377 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import find_text_params, find_files_params, find_symbols_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.find_text_response import FindTextResponse
+from ..types.find_files_response import FindFilesResponse
+from ..types.find_symbols_response import FindSymbolsResponse
+
+__all__ = ["FindResource", "AsyncFindResource"]
+
+
+class FindResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FindResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return FindResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FindResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return FindResourceWithStreamingResponse(self)
+
+    def files(
+        self,
+        *,
+        query: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FindFilesResponse:
+        """
+        Find files
+
+        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
+        """
+        return self._get(
+            "/find/file",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "query": query,
+                        "directory": directory,
+                    },
+                    find_files_params.FindFilesParams,
+                ),
+            ),
+            cast_to=FindFilesResponse,
+        )
+
+    def symbols(
+        self,
+        *,
+        query: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FindSymbolsResponse:
+        """
+        Find workspace symbols
+
+        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
+        """
+        return self._get(
+            "/find/symbol",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "query": query,
+                        "directory": directory,
+                    },
+                    find_symbols_params.FindSymbolsParams,
+                ),
+            ),
+            cast_to=FindSymbolsResponse,
+        )
+
+    def text(
+        self,
+        *,
+        pattern: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FindTextResponse:
+        """
+        Find text in files
+
+        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
+        """
+        return self._get(
+            "/find",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "pattern": pattern,
+                        "directory": directory,
+                    },
+                    find_text_params.FindTextParams,
+                ),
+            ),
+            cast_to=FindTextResponse,
+        )
+
+
+class AsyncFindResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFindResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFindResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFindResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncFindResourceWithStreamingResponse(self)
+
+    async def files(
+        self,
+        *,
+        query: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FindFilesResponse:
+        """
+        Find files
+
+        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
+        """
+        return await self._get(
+            "/find/file",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "query": query,
+                        "directory": directory,
+                    },
+                    find_files_params.FindFilesParams,
+                ),
+            ),
+            cast_to=FindFilesResponse,
+        )
+
+    async def symbols(
+        self,
+        *,
+        query: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FindSymbolsResponse:
+        """
+        Find workspace symbols
+
+        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
+        """
+        return await self._get(
+            "/find/symbol",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "query": query,
+                        "directory": directory,
+                    },
+                    find_symbols_params.FindSymbolsParams,
+                ),
+            ),
+            cast_to=FindSymbolsResponse,
+        )
+
+    async def text(
+        self,
+        *,
+        pattern: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FindTextResponse:
+        """
+        Find text in files
+
+        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
+        """
+        return await self._get(
+            "/find",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "pattern": pattern,
+                        "directory": directory,
+                    },
+                    find_text_params.FindTextParams,
+                ),
+            ),
+            cast_to=FindTextResponse,
+        )
+
+
+class FindResourceWithRawResponse:
+    def __init__(self, find: FindResource) -> None:
+        self._find = find
+
+        self.files = to_raw_response_wrapper(
+            find.files,
+        )
+        self.symbols = to_raw_response_wrapper(
+            find.symbols,
+        )
+        self.text = to_raw_response_wrapper(
+            find.text,
+        )
+
+
+class AsyncFindResourceWithRawResponse:
+    def __init__(self, find: AsyncFindResource) -> None:
+        self._find = find
+
+        self.files = async_to_raw_response_wrapper(
+            find.files,
+        )
+        self.symbols = async_to_raw_response_wrapper(
+            find.symbols,
+        )
+        self.text = async_to_raw_response_wrapper(
+            find.text,
+        )
+
+
+class FindResourceWithStreamingResponse:
+    def __init__(self, find: FindResource) -> None:
+        self._find = find
+
+        self.files = to_streamed_response_wrapper(
+            find.files,
+        )
+        self.symbols = to_streamed_response_wrapper(
+            find.symbols,
+        )
+        self.text = to_streamed_response_wrapper(
+            find.text,
+        )
+
+
+class AsyncFindResourceWithStreamingResponse:
+    def __init__(self, find: AsyncFindResource) -> None:
+        self._find = find
+
+        self.files = async_to_streamed_response_wrapper(
+            find.files,
+        )
+        self.symbols = async_to_streamed_response_wrapper(
+            find.symbols,
+        )
+        self.text = async_to_streamed_response_wrapper(
+            find.text,
+        )

src/opencode_ai/resources/path.py

@@ -0,0 +1,169 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import path_get_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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 ..types.path import Path
+from .._base_client import make_request_options
+
+__all__ = ["PathResource", "AsyncPathResource"]
+
+
+class PathResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PathResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return PathResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PathResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return PathResourceWithStreamingResponse(self)
+
+    def get(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Path:
+        """
+        Get the current path
+
+        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
+        """
+        return self._get(
+            "/path",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, path_get_params.PathGetParams),
+            ),
+            cast_to=Path,
+        )
+
+
+class AsyncPathResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPathResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncPathResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPathResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncPathResourceWithStreamingResponse(self)
+
+    async def get(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Path:
+        """
+        Get the current path
+
+        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
+        """
+        return await self._get(
+            "/path",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, path_get_params.PathGetParams),
+            ),
+            cast_to=Path,
+        )
+
+
+class PathResourceWithRawResponse:
+    def __init__(self, path: PathResource) -> None:
+        self._path = path
+
+        self.get = to_raw_response_wrapper(
+            path.get,
+        )
+
+
+class AsyncPathResourceWithRawResponse:
+    def __init__(self, path: AsyncPathResource) -> None:
+        self._path = path
+
+        self.get = async_to_raw_response_wrapper(
+            path.get,
+        )
+
+
+class PathResourceWithStreamingResponse:
+    def __init__(self, path: PathResource) -> None:
+        self._path = path
+
+        self.get = to_streamed_response_wrapper(
+            path.get,
+        )
+
+
+class AsyncPathResourceWithStreamingResponse:
+    def __init__(self, path: AsyncPathResource) -> None:
+        self._path = path
+
+        self.get = async_to_streamed_response_wrapper(
+            path.get,
+        )

src/opencode_ai/resources/project.py

@@ -0,0 +1,254 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..types import project_list_params, project_current_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.project import Project
+from ..types.project_list_response import ProjectListResponse
+
+__all__ = ["ProjectResource", "AsyncProjectResource"]
+
+
+class ProjectResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ProjectResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return ProjectResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ProjectResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return ProjectResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> ProjectListResponse:
+        """
+        List all projects
+
+        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
+        """
+        return self._get(
+            "/project",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, project_list_params.ProjectListParams),
+            ),
+            cast_to=ProjectListResponse,
+        )
+
+    def current(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Project:
+        """
+        Get the current project
+
+        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
+        """
+        return self._get(
+            "/project/current",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, project_current_params.ProjectCurrentParams),
+            ),
+            cast_to=Project,
+        )
+
+
+class AsyncProjectResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncProjectResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncProjectResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncProjectResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncProjectResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> ProjectListResponse:
+        """
+        List all projects
+
+        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
+        """
+        return await self._get(
+            "/project",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, project_list_params.ProjectListParams),
+            ),
+            cast_to=ProjectListResponse,
+        )
+
+    async def current(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> Project:
+        """
+        Get the current project
+
+        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
+        """
+        return await self._get(
+            "/project/current",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, project_current_params.ProjectCurrentParams
+                ),
+            ),
+            cast_to=Project,
+        )
+
+
+class ProjectResourceWithRawResponse:
+    def __init__(self, project: ProjectResource) -> None:
+        self._project = project
+
+        self.list = to_raw_response_wrapper(
+            project.list,
+        )
+        self.current = to_raw_response_wrapper(
+            project.current,
+        )
+
+
+class AsyncProjectResourceWithRawResponse:
+    def __init__(self, project: AsyncProjectResource) -> None:
+        self._project = project
+
+        self.list = async_to_raw_response_wrapper(
+            project.list,
+        )
+        self.current = async_to_raw_response_wrapper(
+            project.current,
+        )
+
+
+class ProjectResourceWithStreamingResponse:
+    def __init__(self, project: ProjectResource) -> None:
+        self._project = project
+
+        self.list = to_streamed_response_wrapper(
+            project.list,
+        )
+        self.current = to_streamed_response_wrapper(
+            project.current,
+        )
+
+
+class AsyncProjectResourceWithStreamingResponse:
+    def __init__(self, project: AsyncProjectResource) -> None:
+        self._project = project
+
+        self.list = async_to_streamed_response_wrapper(
+            project.list,
+        )
+        self.current = async_to_streamed_response_wrapper(
+            project.current,
+        )

src/opencode_ai/resources/session/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .session import (
+    SessionResource,
+    AsyncSessionResource,
+    SessionResourceWithRawResponse,
+    AsyncSessionResourceWithRawResponse,
+    SessionResourceWithStreamingResponse,
+    AsyncSessionResourceWithStreamingResponse,
+)
+from .permissions import (
+    PermissionsResource,
+    AsyncPermissionsResource,
+    PermissionsResourceWithRawResponse,
+    AsyncPermissionsResourceWithRawResponse,
+    PermissionsResourceWithStreamingResponse,
+    AsyncPermissionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "PermissionsResource",
+    "AsyncPermissionsResource",
+    "PermissionsResourceWithRawResponse",
+    "AsyncPermissionsResourceWithRawResponse",
+    "PermissionsResourceWithStreamingResponse",
+    "AsyncPermissionsResourceWithStreamingResponse",
+    "SessionResource",
+    "AsyncSessionResource",
+    "SessionResourceWithRawResponse",
+    "AsyncSessionResourceWithRawResponse",
+    "SessionResourceWithStreamingResponse",
+    "AsyncSessionResourceWithStreamingResponse",
+]

src/opencode_ai/resources/session/permissions.py

@@ -0,0 +1,189 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.session import permission_respond_params
+from ...types.session.permission_respond_response import PermissionRespondResponse
+
+__all__ = ["PermissionsResource", "AsyncPermissionsResource"]
+
+
+class PermissionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PermissionsResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return PermissionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PermissionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return PermissionsResourceWithStreamingResponse(self)
+
+    def respond(
+        self,
+        permission_id: str,
+        *,
+        id: str,
+        response: Literal["once", "always", "reject"],
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> PermissionRespondResponse:
+        """
+        Respond to a permission request
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        if not permission_id:
+            raise ValueError(f"Expected a non-empty value for `permission_id` but received {permission_id!r}")
+        return self._post(
+            f"/session/{id}/permissions/{permission_id}",
+            body=maybe_transform({"response": response}, permission_respond_params.PermissionRespondParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, permission_respond_params.PermissionRespondParams),
+            ),
+            cast_to=PermissionRespondResponse,
+        )
+
+
+class AsyncPermissionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPermissionsResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncPermissionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPermissionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncPermissionsResourceWithStreamingResponse(self)
+
+    async def respond(
+        self,
+        permission_id: str,
+        *,
+        id: str,
+        response: Literal["once", "always", "reject"],
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> PermissionRespondResponse:
+        """
+        Respond to a permission request
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        if not permission_id:
+            raise ValueError(f"Expected a non-empty value for `permission_id` but received {permission_id!r}")
+        return await self._post(
+            f"/session/{id}/permissions/{permission_id}",
+            body=await async_maybe_transform({"response": response}, permission_respond_params.PermissionRespondParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, permission_respond_params.PermissionRespondParams
+                ),
+            ),
+            cast_to=PermissionRespondResponse,
+        )
+
+
+class PermissionsResourceWithRawResponse:
+    def __init__(self, permissions: PermissionsResource) -> None:
+        self._permissions = permissions
+
+        self.respond = to_raw_response_wrapper(
+            permissions.respond,
+        )
+
+
+class AsyncPermissionsResourceWithRawResponse:
+    def __init__(self, permissions: AsyncPermissionsResource) -> None:
+        self._permissions = permissions
+
+        self.respond = async_to_raw_response_wrapper(
+            permissions.respond,
+        )
+
+
+class PermissionsResourceWithStreamingResponse:
+    def __init__(self, permissions: PermissionsResource) -> None:
+        self._permissions = permissions
+
+        self.respond = to_streamed_response_wrapper(
+            permissions.respond,
+        )
+
+
+class AsyncPermissionsResourceWithStreamingResponse:
+    def __init__(self, permissions: AsyncPermissionsResource) -> None:
+        self._permissions = permissions
+
+        self.respond = async_to_streamed_response_wrapper(
+            permissions.respond,
+        )

src/opencode_ai/resources/tui.py

@@ -0,0 +1,887 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import (
+    tui_open_help_params,
+    tui_show_toast_params,
+    tui_open_models_params,
+    tui_open_themes_params,
+    tui_clear_prompt_params,
+    tui_append_prompt_params,
+    tui_open_sessions_params,
+    tui_submit_prompt_params,
+    tui_execute_command_params,
+)
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.tui_open_help_response import TuiOpenHelpResponse
+from ..types.tui_show_toast_response import TuiShowToastResponse
+from ..types.tui_open_models_response import TuiOpenModelsResponse
+from ..types.tui_open_themes_response import TuiOpenThemesResponse
+from ..types.tui_clear_prompt_response import TuiClearPromptResponse
+from ..types.tui_append_prompt_response import TuiAppendPromptResponse
+from ..types.tui_open_sessions_response import TuiOpenSessionsResponse
+from ..types.tui_submit_prompt_response import TuiSubmitPromptResponse
+from ..types.tui_execute_command_response import TuiExecuteCommandResponse
+
+__all__ = ["TuiResource", "AsyncTuiResource"]
+
+
+class TuiResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TuiResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return TuiResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TuiResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return TuiResourceWithStreamingResponse(self)
+
+    def append_prompt(
+        self,
+        *,
+        text: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiAppendPromptResponse:
+        """
+        Append prompt to the TUI
+
+        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
+        """
+        return self._post(
+            "/tui/append-prompt",
+            body=maybe_transform({"text": text}, tui_append_prompt_params.TuiAppendPromptParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_append_prompt_params.TuiAppendPromptParams),
+            ),
+            cast_to=TuiAppendPromptResponse,
+        )
+
+    def clear_prompt(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiClearPromptResponse:
+        """
+        Clear the prompt
+
+        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
+        """
+        return self._post(
+            "/tui/clear-prompt",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_clear_prompt_params.TuiClearPromptParams),
+            ),
+            cast_to=TuiClearPromptResponse,
+        )
+
+    def execute_command(
+        self,
+        *,
+        command: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiExecuteCommandResponse:
+        """Execute a TUI command (e.g.
+
+        agent_cycle)
+
+        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
+        """
+        return self._post(
+            "/tui/execute-command",
+            body=maybe_transform({"command": command}, tui_execute_command_params.TuiExecuteCommandParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_execute_command_params.TuiExecuteCommandParams),
+            ),
+            cast_to=TuiExecuteCommandResponse,
+        )
+
+    def open_help(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenHelpResponse:
+        """
+        Open the help dialog
+
+        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
+        """
+        return self._post(
+            "/tui/open-help",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_open_help_params.TuiOpenHelpParams),
+            ),
+            cast_to=TuiOpenHelpResponse,
+        )
+
+    def open_models(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenModelsResponse:
+        """
+        Open the model dialog
+
+        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
+        """
+        return self._post(
+            "/tui/open-models",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_open_models_params.TuiOpenModelsParams),
+            ),
+            cast_to=TuiOpenModelsResponse,
+        )
+
+    def open_sessions(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenSessionsResponse:
+        """
+        Open the session dialog
+
+        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
+        """
+        return self._post(
+            "/tui/open-sessions",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_open_sessions_params.TuiOpenSessionsParams),
+            ),
+            cast_to=TuiOpenSessionsResponse,
+        )
+
+    def open_themes(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenThemesResponse:
+        """
+        Open the theme dialog
+
+        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
+        """
+        return self._post(
+            "/tui/open-themes",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_open_themes_params.TuiOpenThemesParams),
+            ),
+            cast_to=TuiOpenThemesResponse,
+        )
+
+    def show_toast(
+        self,
+        *,
+        message: str,
+        variant: Literal["info", "success", "warning", "error"],
+        directory: str | NotGiven = NOT_GIVEN,
+        title: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiShowToastResponse:
+        """
+        Show a toast notification in the TUI
+
+        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
+        """
+        return self._post(
+            "/tui/show-toast",
+            body=maybe_transform(
+                {
+                    "message": message,
+                    "variant": variant,
+                    "title": title,
+                },
+                tui_show_toast_params.TuiShowToastParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_show_toast_params.TuiShowToastParams),
+            ),
+            cast_to=TuiShowToastResponse,
+        )
+
+    def submit_prompt(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiSubmitPromptResponse:
+        """
+        Submit the prompt
+
+        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
+        """
+        return self._post(
+            "/tui/submit-prompt",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"directory": directory}, tui_submit_prompt_params.TuiSubmitPromptParams),
+            ),
+            cast_to=TuiSubmitPromptResponse,
+        )
+
+
+class AsyncTuiResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTuiResourceWithRawResponse:
+        """
+        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/sst/opencode-sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncTuiResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTuiResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/sst/opencode-sdk-python#with_streaming_response
+        """
+        return AsyncTuiResourceWithStreamingResponse(self)
+
+    async def append_prompt(
+        self,
+        *,
+        text: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiAppendPromptResponse:
+        """
+        Append prompt to the TUI
+
+        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
+        """
+        return await self._post(
+            "/tui/append-prompt",
+            body=await async_maybe_transform({"text": text}, tui_append_prompt_params.TuiAppendPromptParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, tui_append_prompt_params.TuiAppendPromptParams
+                ),
+            ),
+            cast_to=TuiAppendPromptResponse,
+        )
+
+    async def clear_prompt(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiClearPromptResponse:
+        """
+        Clear the prompt
+
+        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
+        """
+        return await self._post(
+            "/tui/clear-prompt",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, tui_clear_prompt_params.TuiClearPromptParams
+                ),
+            ),
+            cast_to=TuiClearPromptResponse,
+        )
+
+    async def execute_command(
+        self,
+        *,
+        command: str,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiExecuteCommandResponse:
+        """Execute a TUI command (e.g.
+
+        agent_cycle)
+
+        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
+        """
+        return await self._post(
+            "/tui/execute-command",
+            body=await async_maybe_transform({"command": command}, tui_execute_command_params.TuiExecuteCommandParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, tui_execute_command_params.TuiExecuteCommandParams
+                ),
+            ),
+            cast_to=TuiExecuteCommandResponse,
+        )
+
+    async def open_help(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenHelpResponse:
+        """
+        Open the help dialog
+
+        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
+        """
+        return await self._post(
+            "/tui/open-help",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, tui_open_help_params.TuiOpenHelpParams),
+            ),
+            cast_to=TuiOpenHelpResponse,
+        )
+
+    async def open_models(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenModelsResponse:
+        """
+        Open the model dialog
+
+        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
+        """
+        return await self._post(
+            "/tui/open-models",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, tui_open_models_params.TuiOpenModelsParams),
+            ),
+            cast_to=TuiOpenModelsResponse,
+        )
+
+    async def open_sessions(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenSessionsResponse:
+        """
+        Open the session dialog
+
+        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
+        """
+        return await self._post(
+            "/tui/open-sessions",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, tui_open_sessions_params.TuiOpenSessionsParams
+                ),
+            ),
+            cast_to=TuiOpenSessionsResponse,
+        )
+
+    async def open_themes(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiOpenThemesResponse:
+        """
+        Open the theme dialog
+
+        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
+        """
+        return await self._post(
+            "/tui/open-themes",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, tui_open_themes_params.TuiOpenThemesParams),
+            ),
+            cast_to=TuiOpenThemesResponse,
+        )
+
+    async def show_toast(
+        self,
+        *,
+        message: str,
+        variant: Literal["info", "success", "warning", "error"],
+        directory: str | NotGiven = NOT_GIVEN,
+        title: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiShowToastResponse:
+        """
+        Show a toast notification in the TUI
+
+        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
+        """
+        return await self._post(
+            "/tui/show-toast",
+            body=await async_maybe_transform(
+                {
+                    "message": message,
+                    "variant": variant,
+                    "title": title,
+                },
+                tui_show_toast_params.TuiShowToastParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"directory": directory}, tui_show_toast_params.TuiShowToastParams),
+            ),
+            cast_to=TuiShowToastResponse,
+        )
+
+    async def submit_prompt(
+        self,
+        *,
+        directory: str | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> TuiSubmitPromptResponse:
+        """
+        Submit the prompt
+
+        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
+        """
+        return await self._post(
+            "/tui/submit-prompt",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"directory": directory}, tui_submit_prompt_params.TuiSubmitPromptParams
+                ),
+            ),
+            cast_to=TuiSubmitPromptResponse,
+        )
+
+
+class TuiResourceWithRawResponse:
+    def __init__(self, tui: TuiResource) -> None:
+        self._tui = tui
+
+        self.append_prompt = to_raw_response_wrapper(
+            tui.append_prompt,
+        )
+        self.clear_prompt = to_raw_response_wrapper(
+            tui.clear_prompt,
+        )
+        self.execute_command = to_raw_response_wrapper(
+            tui.execute_command,
+        )
+        self.open_help = to_raw_response_wrapper(
+            tui.open_help,
+        )
+        self.open_models = to_raw_response_wrapper(
+            tui.open_models,
+        )
+        self.open_sessions = to_raw_response_wrapper(
+            tui.open_sessions,
+        )
+        self.open_themes = to_raw_response_wrapper(
+            tui.open_themes,
+        )
+        self.show_toast = to_raw_response_wrapper(
+            tui.show_toast,
+        )
+        self.submit_prompt = to_raw_response_wrapper(
+            tui.submit_prompt,
+        )
+
+
+class AsyncTuiResourceWithRawResponse:
+    def __init__(self, tui: AsyncTuiResource) -> None:
+        self._tui = tui
+
+        self.append_prompt = async_to_raw_response_wrapper(
+            tui.append_prompt,
+        )
+        self.clear_prompt = async_to_raw_response_wrapper(
+            tui.clear_prompt,
+        )
+        self.execute_command = async_to_raw_response_wrapper(
+            tui.execute_command,
+        )
+        self.open_help = async_to_raw_response_wrapper(
+            tui.open_help,
+        )
+        self.open_models = async_to_raw_response_wrapper(
+            tui.open_models,
+        )
+        self.open_sessions = async_to_raw_response_wrapper(
+            tui.open_sessions,
+        )
+        self.open_themes = async_to_raw_response_wrapper(
+            tui.open_themes,
+        )
+        self.show_toast = async_to_raw_response_wrapper(
+            tui.show_toast,
+        )
+        self.submit_prompt = async_to_raw_response_wrapper(
+            tui.submit_prompt,
+        )
+
+
+class TuiResourceWithStreamingResponse:
+    def __init__(self, tui: TuiResource) -> None:
+        self._tui = tui
+
+        self.append_prompt = to_streamed_response_wrapper(
+            tui.append_prompt,
+        )
+        self.clear_prompt = to_streamed_response_wrapper(
+            tui.clear_prompt,
+        )
+        self.execute_command = to_streamed_response_wrapper(
+            tui.execute_command,
+        )
+        self.open_help = to_streamed_response_wrapper(
+            tui.open_help,
+        )
+        self.open_models = to_streamed_response_wrapper(
+            tui.open_models,
+        )
+        self.open_sessions = to_streamed_response_wrapper(
+            tui.open_sessions,
+        )
+        self.open_themes = to_streamed_response_wrapper(
+            tui.open_themes,
+        )
+        self.show_toast = to_streamed_response_wrapper(
+            tui.show_toast,
+        )
+        self.submit_prompt = to_streamed_response_wrapper(
+            tui.submit_prompt,
+        )
+
+
+class AsyncTuiResourceWithStreamingResponse:
+    def __init__(self, tui: AsyncTuiResource) -> None:
+        self._tui = tui
+
+        self.append_prompt = async_to_streamed_response_wrapper(
+            tui.append_prompt,
+        )
+        self.clear_prompt = async_to_streamed_response_wrapper(
+            tui.clear_prompt,
+        )
+        self.execute_command = async_to_streamed_response_wrapper(
+            tui.execute_command,
+        )
+        self.open_help = async_to_streamed_response_wrapper(
+            tui.open_help,
+        )
+        self.open_models = async_to_streamed_response_wrapper(
+            tui.open_models,
+        )
+        self.open_sessions = async_to_streamed_response_wrapper(
+            tui.open_sessions,
+        )
+        self.open_themes = async_to_streamed_response_wrapper(
+            tui.open_themes,
+        )
+        self.show_toast = async_to_streamed_response_wrapper(
+            tui.show_toast,
+        )
+        self.submit_prompt = async_to_streamed_response_wrapper(
+            tui.submit_prompt,
+        )