runloop_api_client 1.4.0__tar.gz → 1.5.1__tar.gz

runloop_api_client-1.5.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.5.1"
+}

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.5.1 (2026-01-30)
+
+Full Changelog: [v1.5.0...v1.5.1](https://github.com/runloopai/api-client-python/compare/v1.5.0...v1.5.1)
+
+### Chores
+
+* **devbox:** rename tunnel auth enum ([#7239](https://github.com/runloopai/api-client-python/issues/7239)) ([7a9b7a4](https://github.com/runloopai/api-client-python/commit/7a9b7a449ce648ad4f220af83b35f800727ea28d))
+
+## 1.5.0 (2026-01-30)
+
+Full Changelog: [v1.4.0...v1.5.0](https://github.com/runloopai/api-client-python/compare/v1.4.0...v1.5.0)
+
+### Features
+
+* **devbox:** add enable_tunnel API ([#7236](https://github.com/runloopai/api-client-python/issues/7236)) ([bb58bfc](https://github.com/runloopai/api-client-python/commit/bb58bfc40c93c5832634ddb82c255ada7214c7f4))
+
 ## 1.4.0 (2026-01-30)
 
 Full Changelog: [v1.3.2...v1.4.0](https://github.com/runloopai/api-client-python/compare/v1.3.2...v1.4.0)

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: runloop_api_client
-Version: 1.4.0
+Version: 1.5.1
 Summary: The official Python library for the runloop API
 Project-URL: Homepage, https://github.com/runloopai/api-client-python
 Project-URL: Repository, https://github.com/runloopai/api-client-python

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/api.md

@@ -132,6 +132,7 @@ from runloop_api_client.types import (
     DevboxSnapshotView,
     DevboxTunnelView,
     DevboxView,
+    TunnelView,
     DevboxCreateSSHKeyResponse,
     DevboxReadFileContentsResponse,
 )
@@ -148,6 +149,7 @@ Methods:
 - <code title="post /v1/devboxes/{id}/create_tunnel">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">create_tunnel</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_create_tunnel_params.py">params</a>) -> <a href="./src/runloop_api_client/types/devbox_tunnel_view.py">DevboxTunnelView</a></code>
 - <code title="post /v1/devboxes/disk_snapshots/{id}/delete">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">delete_disk_snapshot</a>(id) -> object</code>
 - <code title="post /v1/devboxes/{id}/download_file">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">download_file</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_download_file_params.py">params</a>) -> BinaryAPIResponse</code>
+- <code title="post /v1/devboxes/{id}/enable_tunnel">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">enable_tunnel</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_enable_tunnel_params.py">params</a>) -> <a href="./src/runloop_api_client/types/tunnel_view.py">TunnelView</a></code>
 - <code title="post /v1/devboxes/{id}/execute">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">execute</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_execute_params.py">params</a>) -> <a href="./src/runloop_api_client/types/devbox_async_execution_detail_view.py">DevboxAsyncExecutionDetailView</a></code>
 - <code title="post /v1/devboxes/{id}/execute_async">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">execute_async</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_execute_async_params.py">params</a>) -> <a href="./src/runloop_api_client/types/devbox_async_execution_detail_view.py">DevboxAsyncExecutionDetailView</a></code>
 - <code title="post /v1/devboxes/{id}/execute_sync">client.devboxes.<a href="./src/runloop_api_client/resources/devboxes/devboxes.py">execute_sync</a>(id, \*\*<a href="src/runloop_api_client/types/devbox_execute_sync_params.py">params</a>) -> <a href="./src/runloop_api_client/types/devbox_execution_detail_view.py">DevboxExecutionDetailView</a></code>

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runloop_api_client"
-version = "1.4.0"
+version = "1.5.1"
 description = "The official Python library for the runloop API"
 dynamic = ["readme"]
 license = "MIT"

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "runloop_api_client"
-__version__ = "1.4.0"  # x-release-please-version
+__version__ = "1.5.1"  # x-release-please-version

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/resources/devboxes/devboxes.py

@@ -28,6 +28,7 @@ from ...types import (
     devbox_execute_sync_params,
     devbox_create_tunnel_params,
     devbox_download_file_params,
+    devbox_enable_tunnel_params,
     devbox_execute_async_params,
     devbox_remove_tunnel_params,
     devbox_snapshot_disk_params,
@@ -99,6 +100,7 @@ from .disk_snapshots import (
 )
 from ...lib.polling_async import async_poll_until
 from ...types.devbox_view import DevboxView
+from ...types.tunnel_view import TunnelView
 from ...types.devbox_tunnel_view import DevboxTunnelView
 from ...types.shared_params.mount import Mount
 from ...types.devbox_snapshot_view import DevboxSnapshotView
@@ -787,6 +789,55 @@ class DevboxesResource(SyncAPIResource):
             cast_to=BinaryAPIResponse,
         )
 
+    def enable_tunnel(
+        self,
+        id: str,
+        *,
+        auth_mode: Optional[Literal["open", "authenticated"]] | Omit = omit,
+        # 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,
+        idempotency_key: str | None = None,
+    ) -> TunnelView:
+        """Create a V2 tunnel for an existing running Devbox.
+
+        Tunnels provide encrypted
+        URL-based access to the Devbox without exposing internal IDs. The tunnel URL
+        format is: https://{port}-{tunnel_key}.tunnel.runloop.ai
+
+        Each Devbox can have one tunnel.
+
+        Args:
+          auth_mode: Authentication mode for the tunnel. Defaults to 'public' if not specified.
+
+          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
+
+          idempotency_key: Specify a custom idempotency key for this request
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._post(
+            f"/v1/devboxes/{id}/enable_tunnel",
+            body=maybe_transform({"auth_mode": auth_mode}, devbox_enable_tunnel_params.DevboxEnableTunnelParams),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                idempotency_key=idempotency_key,
+            ),
+            cast_to=TunnelView,
+        )
+
     def execute(
         self,
         id: str,
@@ -2347,6 +2398,57 @@ class AsyncDevboxesResource(AsyncAPIResource):
             cast_to=AsyncBinaryAPIResponse,
         )
 
+    async def enable_tunnel(
+        self,
+        id: str,
+        *,
+        auth_mode: Optional[Literal["open", "authenticated"]] | Omit = omit,
+        # 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,
+        idempotency_key: str | None = None,
+    ) -> TunnelView:
+        """Create a V2 tunnel for an existing running Devbox.
+
+        Tunnels provide encrypted
+        URL-based access to the Devbox without exposing internal IDs. The tunnel URL
+        format is: https://{port}-{tunnel_key}.tunnel.runloop.ai
+
+        Each Devbox can have one tunnel.
+
+        Args:
+          auth_mode: Authentication mode for the tunnel. Defaults to 'public' if not specified.
+
+          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
+
+          idempotency_key: Specify a custom idempotency key for this request
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._post(
+            f"/v1/devboxes/{id}/enable_tunnel",
+            body=await async_maybe_transform(
+                {"auth_mode": auth_mode}, devbox_enable_tunnel_params.DevboxEnableTunnelParams
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                idempotency_key=idempotency_key,
+            ),
+            cast_to=TunnelView,
+        )
+
     async def execute(
         self,
         id: str,
@@ -3293,6 +3395,9 @@ class DevboxesResourceWithRawResponse:
             devboxes.download_file,
             BinaryAPIResponse,
         )
+        self.enable_tunnel = to_raw_response_wrapper(
+            devboxes.enable_tunnel,
+        )
         self.execute = to_raw_response_wrapper(
             devboxes.execute,
         )
@@ -3395,6 +3500,9 @@ class AsyncDevboxesResourceWithRawResponse:
             devboxes.download_file,
             AsyncBinaryAPIResponse,
         )
+        self.enable_tunnel = async_to_raw_response_wrapper(
+            devboxes.enable_tunnel,
+        )
         self.execute = async_to_raw_response_wrapper(
             devboxes.execute,
         )
@@ -3497,6 +3605,9 @@ class DevboxesResourceWithStreamingResponse:
             devboxes.download_file,
             StreamedBinaryAPIResponse,
         )
+        self.enable_tunnel = to_streamed_response_wrapper(
+            devboxes.enable_tunnel,
+        )
         self.execute = to_streamed_response_wrapper(
             devboxes.execute,
         )
@@ -3599,6 +3710,9 @@ class AsyncDevboxesResourceWithStreamingResponse:
             devboxes.download_file,
             AsyncStreamedBinaryAPIResponse,
         )
+        self.enable_tunnel = async_to_streamed_response_wrapper(
+            devboxes.enable_tunnel,
+        )
         self.execute = async_to_streamed_response_wrapper(
             devboxes.execute,
         )

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/sdk/_types.py

@@ -22,6 +22,7 @@ from ..types import (
     NetworkPolicyListParams,
     DevboxCreateTunnelParams,
     DevboxDownloadFileParams,
+    DevboxEnableTunnelParams,
     DevboxRemoveTunnelParams,
     DevboxSnapshotDiskParams,
     NetworkPolicyCreateParams,
@@ -121,6 +122,10 @@ class SDKDevboxCreateTunnelParams(DevboxCreateTunnelParams, LongRequestOptions):
     pass
 
 
+class SDKDevboxEnableTunnelParams(DevboxEnableTunnelParams, LongRequestOptions):
+    pass
+
+
 class SDKDevboxRemoveTunnelParams(DevboxRemoveTunnelParams, LongRequestOptions):
     pass
 

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/sdk/async_devbox.py

@@ -10,6 +10,7 @@ from typing_extensions import Unpack, override
 
 from ..types import (
     DevboxView,
+    TunnelView,
     DevboxTunnelView,
     DevboxExecutionDetailView,
     DevboxCreateSSHKeyResponse,
@@ -24,6 +25,7 @@ from ._types import (
     SDKDevboxUploadFileParams,
     SDKDevboxCreateTunnelParams,
     SDKDevboxDownloadFileParams,
+    SDKDevboxEnableTunnelParams,
     SDKDevboxExecuteAsyncParams,
     SDKDevboxRemoveTunnelParams,
     SDKDevboxSnapshotDiskParams,
@@ -731,7 +733,9 @@ class AsyncNetworkInterface:
         self,
         **params: Unpack[SDKDevboxCreateTunnelParams],
     ) -> DevboxTunnelView:
-        """Create a network tunnel to expose a devbox port publicly.
+        """[Deprecated] Create a legacy tunnel to expose a devbox port publicly.
+
+        Use :meth:`enable_tunnel` instead for the V2 tunnel API.
 
         :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxCreateTunnelParams` for available parameters
         :return: Details about the public endpoint
@@ -748,6 +752,30 @@ class AsyncNetworkInterface:
                 **params,
             )
 
+    async def enable_tunnel(
+        self,
+        **params: Unpack[SDKDevboxEnableTunnelParams],
+    ) -> TunnelView:
+        """Enable a V2 tunnel for secure HTTP access to the devbox.
+
+        V2 tunnels provide encrypted URL-based access without exposing internal IDs.
+        Each devbox can have one tunnel. The tunnel URL format is:
+        ``https://{port}-{tunnel_key}.tunnel.runloop.ai``
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxEnableTunnelParams` for available parameters
+        :return: Tunnel details including the tunnel key for constructing URLs
+        :rtype: TunnelView
+
+        Example:
+            >>> tunnel = await devbox.net.enable_tunnel(auth_mode="open")
+            >>> print(f"Tunnel key: {tunnel.tunnel_key}")
+            >>> # Access via: https://8080-{tunnel.tunnel_key}.tunnel.runloop.ai
+        """
+        return await self._devbox._client.devboxes.enable_tunnel(
+            self._devbox.id,
+            **params,
+        )
+
     async def remove_tunnel(
         self,
         **params: Unpack[SDKDevboxRemoveTunnelParams],

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/sdk/devbox.py

@@ -10,6 +10,7 @@ from typing_extensions import Unpack, override
 
 from ..types import (
     DevboxView,
+    TunnelView,
     DevboxTunnelView,
     DevboxExecutionDetailView,
     DevboxCreateSSHKeyResponse,
@@ -25,6 +26,7 @@ from ._types import (
     SDKDevboxUploadFileParams,
     SDKDevboxCreateTunnelParams,
     SDKDevboxDownloadFileParams,
+    SDKDevboxEnableTunnelParams,
     SDKDevboxExecuteAsyncParams,
     SDKDevboxRemoveTunnelParams,
     SDKDevboxSnapshotDiskParams,
@@ -734,7 +736,9 @@ class NetworkInterface:
         self,
         **params: Unpack[SDKDevboxCreateTunnelParams],
     ) -> DevboxTunnelView:
-        """Create a network tunnel to expose a devbox port publicly.
+        """[Deprecated] Create a legacy tunnel to expose a devbox port publicly.
+
+        Use :meth:`enable_tunnel` instead for the V2 tunnel API.
 
         :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxCreateTunnelParams` for available parameters
         :return: Details about the public endpoint
@@ -751,6 +755,30 @@ class NetworkInterface:
                 **params,
             )
 
+    def enable_tunnel(
+        self,
+        **params: Unpack[SDKDevboxEnableTunnelParams],
+    ) -> TunnelView:
+        """Enable a V2 tunnel for secure HTTP access to the devbox.
+
+        V2 tunnels provide encrypted URL-based access without exposing internal IDs.
+        Each devbox can have one tunnel. The tunnel URL format is:
+        ``https://{port}-{tunnel_key}.tunnel.runloop.ai``
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxEnableTunnelParams` for available parameters
+        :return: Tunnel details including the tunnel key for constructing URLs
+        :rtype: :class:`~runloop_api_client.types.tunnel_view.TunnelView`
+
+        Example:
+            >>> tunnel = devbox.net.enable_tunnel(auth_mode="open")
+            >>> print(f"Tunnel key: {tunnel.tunnel_key}")
+            >>> # Access via: https://8080-{tunnel.tunnel_key}.tunnel.runloop.ai
+        """
+        return self._devbox._client.devboxes.enable_tunnel(
+            self._devbox.id,
+            **params,
+        )
+
     def remove_tunnel(
         self,
         **params: Unpack[SDKDevboxRemoveTunnelParams],

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/types/__init__.py

@@ -16,6 +16,7 @@ from .agent_view import AgentView as AgentView
 from .devbox_view import DevboxView as DevboxView
 from .object_view import ObjectView as ObjectView
 from .secret_view import SecretView as SecretView
+from .tunnel_view import TunnelView as TunnelView
 from .input_context import InputContext as InputContext
 from .scenario_view import ScenarioView as ScenarioView
 from .benchmark_view import BenchmarkView as BenchmarkView
@@ -91,6 +92,7 @@ from .scenario_environment_param import ScenarioEnvironmentParam as ScenarioEnvi
 from .benchmark_job_create_params import BenchmarkJobCreateParams as BenchmarkJobCreateParams
 from .devbox_create_tunnel_params import DevboxCreateTunnelParams as DevboxCreateTunnelParams
 from .devbox_download_file_params import DevboxDownloadFileParams as DevboxDownloadFileParams
+from .devbox_enable_tunnel_params import DevboxEnableTunnelParams as DevboxEnableTunnelParams
 from .devbox_execute_async_params import DevboxExecuteAsyncParams as DevboxExecuteAsyncParams
 from .devbox_remove_tunnel_params import DevboxRemoveTunnelParams as DevboxRemoveTunnelParams
 from .devbox_snapshot_disk_params import DevboxSnapshotDiskParams as DevboxSnapshotDiskParams

runloop_api_client-1.5.1/src/runloop_api_client/types/devbox_enable_tunnel_params.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["DevboxEnableTunnelParams"]
+
+
+class DevboxEnableTunnelParams(TypedDict, total=False):
+    auth_mode: Optional[Literal["open", "authenticated"]]
+    """Authentication mode for the tunnel. Defaults to 'public' if not specified."""

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/src/runloop_api_client/types/devbox_view.py

@@ -4,9 +4,10 @@ from typing import Dict, List, Optional
 from typing_extensions import Literal
 
 from .._models import BaseModel
+from .tunnel_view import TunnelView
 from .shared.launch_parameters import LaunchParameters
 
-__all__ = ["DevboxView", "StateTransition", "GatewaySpecs", "Tunnel"]
+__all__ = ["DevboxView", "StateTransition", "GatewaySpecs"]
 
 
 class StateTransition(BaseModel):
@@ -38,30 +39,6 @@ class GatewaySpecs(BaseModel):
     """The ID of the secret containing the credential."""
 
 
-class Tunnel(BaseModel):
-    """
-    V2 tunnel information if a tunnel was created at launch time or via the createTunnel API.
-    """
-
-    auth_mode: Literal["public_", "authenticated"]
-    """The authentication mode for the tunnel."""
-
-    create_time_ms: int
-    """Creation time of the tunnel (Unix timestamp milliseconds)."""
-
-    tunnel_key: str
-    """The encrypted tunnel key used to construct the tunnel URL.
-
-    URL format: https://{port}-{tunnel_key}.tunnel.runloop.{domain}
-    """
-
-    auth_token: Optional[str] = None
-    """Bearer token for tunnel authentication.
-
-    Only present when auth_mode is 'authenticated'.
-    """
-
-
 class DevboxView(BaseModel):
     """A Devbox represents a virtual development environment.
 
@@ -137,7 +114,7 @@ class DevboxView(BaseModel):
     Snapshot.
     """
 
-    tunnel: Optional[Tunnel] = None
+    tunnel: Optional[TunnelView] = None
     """
     V2 tunnel information if a tunnel was created at launch time or via the
     createTunnel API.

runloop_api_client-1.5.1/src/runloop_api_client/types/tunnel_view.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["TunnelView"]
+
+
+class TunnelView(BaseModel):
+    """A V2 tunnel provides secure HTTP access to services running on a Devbox.
+
+    Tunnels allow external clients to reach web servers, APIs, or other HTTP services running inside a Devbox without requiring direct network access. Each tunnel is uniquely identified by an encrypted tunnel_key and can be configured for either open (public) or authenticated access.
+    Usage: https://{port}-{tunnel_key}.tunnel.runloop.ai
+    """
+
+    auth_mode: Literal["open", "authenticated"]
+    """The authentication mode for the tunnel."""
+
+    create_time_ms: int
+    """Creation time of the tunnel (Unix timestamp milliseconds)."""
+
+    tunnel_key: str
+    """The encrypted tunnel key used to construct the tunnel URL.
+
+    URL format: https://{port}-{tunnel_key}.tunnel.runloop.{domain}
+    """
+
+    auth_token: Optional[str] = None
+    """Bearer token for tunnel authentication.
+
+    Only present when auth_mode is 'authenticated'.
+    """

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/tests/api_resources/test_devboxes.py

@@ -14,6 +14,7 @@ from tests.utils import assert_matches_type
 from runloop_api_client import Runloop, AsyncRunloop
 from runloop_api_client.types import (
     DevboxView,
+    TunnelView,
     DevboxTunnelView,
     DevboxSnapshotView,
     DevboxExecutionDetailView,
@@ -427,6 +428,52 @@ class TestDevboxes:
                 path="path",
             )
 
+    @parametrize
+    def test_method_enable_tunnel(self, client: Runloop) -> None:
+        devbox = client.devboxes.enable_tunnel(
+            id="id",
+        )
+        assert_matches_type(TunnelView, devbox, path=["response"])
+
+    @parametrize
+    def test_method_enable_tunnel_with_all_params(self, client: Runloop) -> None:
+        devbox = client.devboxes.enable_tunnel(
+            id="id",
+            auth_mode="open",
+        )
+        assert_matches_type(TunnelView, devbox, path=["response"])
+
+    @parametrize
+    def test_raw_response_enable_tunnel(self, client: Runloop) -> None:
+        response = client.devboxes.with_raw_response.enable_tunnel(
+            id="id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        devbox = response.parse()
+        assert_matches_type(TunnelView, devbox, path=["response"])
+
+    @parametrize
+    def test_streaming_response_enable_tunnel(self, client: Runloop) -> None:
+        with client.devboxes.with_streaming_response.enable_tunnel(
+            id="id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            devbox = response.parse()
+            assert_matches_type(TunnelView, devbox, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_path_params_enable_tunnel(self, client: Runloop) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            client.devboxes.with_raw_response.enable_tunnel(
+                id="",
+            )
+
     @parametrize
     def test_method_execute(self, client: Runloop) -> None:
         devbox = client.devboxes.execute(
@@ -1993,6 +2040,52 @@ class TestAsyncDevboxes:
                 path="path",
             )
 
+    @parametrize
+    async def test_method_enable_tunnel(self, async_client: AsyncRunloop) -> None:
+        devbox = await async_client.devboxes.enable_tunnel(
+            id="id",
+        )
+        assert_matches_type(TunnelView, devbox, path=["response"])
+
+    @parametrize
+    async def test_method_enable_tunnel_with_all_params(self, async_client: AsyncRunloop) -> None:
+        devbox = await async_client.devboxes.enable_tunnel(
+            id="id",
+            auth_mode="open",
+        )
+        assert_matches_type(TunnelView, devbox, path=["response"])
+
+    @parametrize
+    async def test_raw_response_enable_tunnel(self, async_client: AsyncRunloop) -> None:
+        response = await async_client.devboxes.with_raw_response.enable_tunnel(
+            id="id",
+        )
+
+        assert response.is_closed is True
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        devbox = await response.parse()
+        assert_matches_type(TunnelView, devbox, path=["response"])
+
+    @parametrize
+    async def test_streaming_response_enable_tunnel(self, async_client: AsyncRunloop) -> None:
+        async with async_client.devboxes.with_streaming_response.enable_tunnel(
+            id="id",
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            devbox = await response.parse()
+            assert_matches_type(TunnelView, devbox, path=["response"])
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_path_params_enable_tunnel(self, async_client: AsyncRunloop) -> None:
+        with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"):
+            await async_client.devboxes.with_raw_response.enable_tunnel(
+                id="",
+            )
+
     @parametrize
     async def test_method_execute(self, async_client: AsyncRunloop) -> None:
         devbox = await async_client.devboxes.execute(

{runloop_api_client-1.4.0 → runloop_api_client-1.5.1}/tests/smoketests/sdk/test_async_devbox.py

@@ -458,6 +458,53 @@ class TestAsyncDevboxNetworking:
         finally:
             await devbox.shutdown()
 
+    @pytest.mark.timeout(TWO_MINUTE_TIMEOUT)
+    async def test_create_with_tunnel_param(self, async_sdk_client: AsyncRunloopSDK) -> None:
+        """Test creating a devbox with tunnel configuration in create params."""
+        devbox = await async_sdk_client.devbox.create(
+            name=unique_name("sdk-async-devbox-tunnel-param"),
+            launch_parameters={"resource_size_request": "SMALL", "keep_alive_time_seconds": 60 * 5},
+            tunnel={"auth_mode": "open"},
+        )
+
+        try:
+            # Verify devbox is running
+            info = await devbox.get_info()
+            assert info.status == "running"
+
+            # Verify tunnel was created at launch
+            assert info.tunnel is not None
+            assert info.tunnel.tunnel_key is not None
+            assert info.tunnel.auth_mode is not None
+        finally:
+            await devbox.shutdown()
+
+    @pytest.mark.timeout(TWO_MINUTE_TIMEOUT)
+    async def test_enable_tunnel(self, async_sdk_client: AsyncRunloopSDK) -> None:
+        """Test enabling a V2 tunnel on an existing devbox."""
+        devbox = await async_sdk_client.devbox.create(
+            name=unique_name("sdk-async-devbox-enable-tunnel"),
+            launch_parameters={"resource_size_request": "SMALL", "keep_alive_time_seconds": 60 * 5},
+        )
+
+        try:
+            # Verify no tunnel exists initially
+            info = await devbox.get_info()
+            assert info.tunnel is None
+
+            # Enable tunnel using the V2 API via SDK
+            tunnel = await devbox.net.enable_tunnel(auth_mode="open")
+            assert tunnel is not None
+            assert tunnel.tunnel_key is not None
+            assert tunnel.auth_mode is not None
+
+            # Verify tunnel is now present in devbox info
+            info = await devbox.get_info()
+            assert info.tunnel is not None
+            assert info.tunnel.tunnel_key == tunnel.tunnel_key
+        finally:
+            await devbox.shutdown()
+
 
 class TestAsyncDevboxCreationMethods:
     """Test various async devbox creation methods."""