feat(api): update via SDK Studio

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 5
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/kernel%2Fkernel-3b19f5e2b96ede3193aa7a24d3f82d1406b8a16ea25e98ba3956e4a1a2376ad7.yml
-openapi_spec_hash: b62a6e73ddcec71674973f795a5790ac
-config_hash: df889df131f7438197abd59faace3c77
+configured_endpoints: 6
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/kernel%2Fkernel-19b0d17ba368f32827ee322d15a7f4ff7e1f3bbf66606fad227b3465f8ffc5ab.yml
+openapi_spec_hash: 4a3cb766898e8a134ef99fe6c4c87736
+config_hash: 9018b7ff17f8de1bc3e99a0ae2f2df68

api.md

@@ -5,12 +5,13 @@
 Types:
 
 ```python
-from kernel.types.apps import DeploymentCreateResponse
+from kernel.types.apps import DeploymentCreateResponse, DeploymentFollowResponse
 ```
 
 Methods:
 
 - <code title="post /deploy">client.apps.deployments.<a href="./src/kernel/resources/apps/deployments.py">create</a>(\*\*<a href="src/kernel/types/apps/deployment_create_params.py">params</a>) -> <a href="./src/kernel/types/apps/deployment_create_response.py">DeploymentCreateResponse</a></code>
+- <code title="get /apps/{id}/events">client.apps.deployments.<a href="./src/kernel/resources/apps/deployments.py">follow</a>(id) -> <a href="./src/kernel/types/apps/deployment_follow_response.py">DeploymentFollowResponse</a></code>
 
 ## Invocations
 

src/kernel/resources/apps/deployments.py

@@ -17,9 +17,11 @@
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
+from ..._streaming import Stream, AsyncStream
 from ...types.apps import deployment_create_params
 from ..._base_client import make_request_options
 from ...types.apps.deployment_create_response import DeploymentCreateResponse
+from ...types.apps.deployment_follow_response import DeploymentFollowResponse
 
 __all__ = ["DeploymentsResource", "AsyncDeploymentsResource"]
 
@@ -110,6 +112,44 @@ def create(
             cast_to=DeploymentCreateResponse,
         )
 
+    def follow(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Stream[DeploymentFollowResponse]:
+        """
+        Establishes a Server-Sent Events (SSE) stream that delivers real-time logs and
+        status updates for a deployed application. The stream terminates automatically
+        once the application reaches a terminal state.
+
+        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}")
+        extra_headers = {"Accept": "text/event-stream", **(extra_headers or {})}
+        return self._get(
+            f"/apps/{id}/events",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeploymentFollowResponse,
+            stream=True,
+            stream_cls=Stream[DeploymentFollowResponse],
+        )
+
 
 class AsyncDeploymentsResource(AsyncAPIResource):
     @cached_property
@@ -197,6 +237,44 @@ async def create(
             cast_to=DeploymentCreateResponse,
         )
 
+    async def follow(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncStream[DeploymentFollowResponse]:
+        """
+        Establishes a Server-Sent Events (SSE) stream that delivers real-time logs and
+        status updates for a deployed application. The stream terminates automatically
+        once the application reaches a terminal state.
+
+        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}")
+        extra_headers = {"Accept": "text/event-stream", **(extra_headers or {})}
+        return await self._get(
+            f"/apps/{id}/events",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeploymentFollowResponse,
+            stream=True,
+            stream_cls=AsyncStream[DeploymentFollowResponse],
+        )
+
 
 class DeploymentsResourceWithRawResponse:
     def __init__(self, deployments: DeploymentsResource) -> None:
@@ -205,6 +283,9 @@ def __init__(self, deployments: DeploymentsResource) -> None:
         self.create = to_raw_response_wrapper(
             deployments.create,
         )
+        self.follow = to_raw_response_wrapper(
+            deployments.follow,
+        )
 
 
 class AsyncDeploymentsResourceWithRawResponse:
@@ -214,6 +295,9 @@ def __init__(self, deployments: AsyncDeploymentsResource) -> None:
         self.create = async_to_raw_response_wrapper(
             deployments.create,
         )
+        self.follow = async_to_raw_response_wrapper(
+            deployments.follow,
+        )
 
 
 class DeploymentsResourceWithStreamingResponse:
@@ -223,6 +307,9 @@ def __init__(self, deployments: DeploymentsResource) -> None:
         self.create = to_streamed_response_wrapper(
             deployments.create,
         )
+        self.follow = to_streamed_response_wrapper(
+            deployments.follow,
+        )
 
 
 class AsyncDeploymentsResourceWithStreamingResponse:
@@ -232,3 +319,6 @@ def __init__(self, deployments: AsyncDeploymentsResource) -> None:
         self.create = async_to_streamed_response_wrapper(
             deployments.create,
         )
+        self.follow = async_to_streamed_response_wrapper(
+            deployments.follow,
+        )

src/kernel/types/apps/__init__.py

@@ -5,5 +5,6 @@
 from .deployment_create_params import DeploymentCreateParams as DeploymentCreateParams
 from .invocation_create_params import InvocationCreateParams as InvocationCreateParams
 from .deployment_create_response import DeploymentCreateResponse as DeploymentCreateResponse
+from .deployment_follow_response import DeploymentFollowResponse as DeploymentFollowResponse
 from .invocation_create_response import InvocationCreateResponse as InvocationCreateResponse
 from .invocation_retrieve_response import InvocationRetrieveResponse as InvocationRetrieveResponse

src/kernel/types/apps/deployment_follow_response.py

@@ -0,0 +1,63 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+
+__all__ = [
+    "DeploymentFollowResponse",
+    "DeploymentFollowResponseItem",
+    "DeploymentFollowResponseItemStateEvent",
+    "DeploymentFollowResponseItemStateUpdateEvent",
+    "DeploymentFollowResponseItemLogEvent",
+]
+
+
+class DeploymentFollowResponseItemStateEvent(BaseModel):
+    event: Literal["state"]
+    """Event type identifier (always "state")."""
+
+    state: str
+    """
+    Current application state (e.g., "deploying", "running", "succeeded", "failed").
+    """
+
+    timestamp: Optional[datetime] = None
+    """Time the state was reported."""
+
+
+class DeploymentFollowResponseItemStateUpdateEvent(BaseModel):
+    event: Literal["state_update"]
+    """Event type identifier (always "state_update")."""
+
+    state: str
+    """New application state (e.g., "running", "succeeded", "failed")."""
+
+    timestamp: Optional[datetime] = None
+    """Time the state change occurred."""
+
+
+class DeploymentFollowResponseItemLogEvent(BaseModel):
+    event: Literal["log"]
+    """Event type identifier (always "log")."""
+
+    message: str
+    """Log message text."""
+
+    timestamp: Optional[datetime] = None
+    """Time the log entry was produced."""
+
+
+DeploymentFollowResponseItem: TypeAlias = Annotated[
+    Union[
+        DeploymentFollowResponseItemStateEvent,
+        DeploymentFollowResponseItemStateUpdateEvent,
+        DeploymentFollowResponseItemLogEvent,
+    ],
+    PropertyInfo(discriminator="event"),
+]
+
+DeploymentFollowResponse: TypeAlias = List[DeploymentFollowResponseItem]

tests/api_resources/apps/test_deployments.py

@@ -67,6 +67,55 @@ def test_streaming_response_create(self, client: Kernel) -> None:
 
         assert cast(Any, response.is_closed) is True
 
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    def test_method_follow(self, client: Kernel) -> None:
+        deployment_stream = client.apps.deployments.follow(
+            "id",
+        )
+        deployment_stream.response.close()
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    def test_raw_response_follow(self, client: Kernel) -> None:
+        response = client.apps.deployments.with_raw_response.follow(
+            "id",
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    def test_streaming_response_follow(self, client: Kernel) -> None:
+        with client.apps.deployments.with_streaming_response.follow(
+            "id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    def test_path_params_follow(self, client: Kernel) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            client.apps.deployments.with_raw_response.follow(
+                "",
+            )
+
 
 class TestAsyncDeployments:
     parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"])
@@ -120,3 +169,52 @@ async def test_streaming_response_create(self, async_client: AsyncKernel) -> Non
             assert_matches_type(DeploymentCreateResponse, deployment, path=["response"])
 
         assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    async def test_method_follow(self, async_client: AsyncKernel) -> None:
+        deployment_stream = await async_client.apps.deployments.follow(
+            "id",
+        )
+        await deployment_stream.response.aclose()
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    async def test_raw_response_follow(self, async_client: AsyncKernel) -> None:
+        response = await async_client.apps.deployments.with_raw_response.follow(
+            "id",
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = await response.parse()
+        await stream.close()
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    async def test_streaming_response_follow(self, async_client: AsyncKernel) -> None:
+        async with async_client.apps.deployments.with_streaming_response.follow(
+            "id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @pytest.mark.skip(
+        reason="currently no good way to test endpoints with content type text/event-stream, Prism mock server will fail"
+    )
+    @parametrize
+    async def test_path_params_follow(self, async_client: AsyncKernel) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            await async_client.apps.deployments.with_raw_response.follow(
+                "",
+            )