modal 1.5.3.dev5__tar.gz → 1.5.3.dev7__tar.gz

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.3.dev5
+Version: 1.5.3.dev7
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/_environments.py

@@ -104,11 +104,7 @@ class _EnvironmentManager:
 
 
 class _EnvironmentMembersManager:
-    """mdmd:namespace
-    Namespace with methods for managing the membership of a restricted Environment.
-
-    See https://modal.com/docs/guide/rbac for more information on restricted Environments.
-    """
+    """mdmd:namespace"""
 
     def __init__(self, environment: "_Environment"):
         """mdmd:hidden"""
@@ -288,6 +284,10 @@ class _Environment(_Object, type_prefix="en"):
 
     @property
     def members(self) -> "_EnvironmentMembersManager":
+        """Namespace with methods for managing the membership of a restricted Environment.
+
+        See https://modal.com/docs/guide/rbac for more information on restricted Environments.
+        """
         return _EnvironmentMembersManager(self)
 
     # TODO(michael) Keeping this private for now until we decide what else should be in it
@@ -372,13 +372,12 @@ class _Environment(_Object, type_prefix="en"):
 
     @property
     def billing(self) -> "_EnvironmentBillingManager":
+        """Namespace for Environment billing APIs."""
         return _EnvironmentBillingManager(self)
 
 
 class _EnvironmentBillingManager:
-    """mdmd:namespace
-    Namespace for Environment billing APIs
-    """
+    """mdmd:namespace"""
 
     def __init__(self, environment: _Environment):
         """mdmd:ignore"""

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/_functions.py

@@ -2073,11 +2073,13 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
 
     @live_method
     async def get_call_graph(self) -> list[InputInfo]:
-        """Returns a structure representing the call graph from a given root
-        call ID, along with the status of execution for each node.
+        """Fetch information about the graph of Inputs this FunctionCall is part of.
 
-        See [`modal.call_graph`](https://modal.com/docs/sdk/py/latest/modal.call_graph) reference page
-        for documentation on the structure of the returned `InputInfo` items.
+        Note: the call graph data is not populated in real-time, and its capture is best-effort.
+        We do not recommend relying on this method for critical use cases.
+
+        See the [`modal.types`](/docs/sdk/py/latest/modal.types) reference for information
+        on the return values.
 
         Returns:
             A list of `InputInfo` nodes describing the call graph.
@@ -2088,19 +2090,13 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         return _reconstruct_call_graph(response)
 
     @live_method
-    async def cancel(
-        self,
-        # if true, containers running the inputs are forcibly terminated
-        terminate_containers: bool = False,
-    ):
-        """Cancels the function call, which will stop its execution and mark its inputs as
-        [`TERMINATED`](https://modal.com/docs/sdk/py/latest/modal.call_graph#modalcall_graphinputstatus).
-
-        If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-        causing any non-cancelled inputs on those containers to be rescheduled in new containers.
+    async def cancel(self, terminate_containers: bool = False):
+        """Cancel the FunctionCall and terminate its inputs without retrying.
 
         Args:
-            terminate_containers: If True, forcibly terminate workers running cancelled inputs.
+            terminate_containers: If True, terminate the containers running the cancelled
+                inputs. Any other inputs running concurrently on those containers will be
+                rescheduled.
         """
         request = api_pb2.FunctionCallCancelRequest(
             function_call_id=self.object_id, terminate_containers=terminate_containers

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/_utils/task_command_router_client.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2025
 import asyncio
 import base64
+import io
 import json
 import socket
 import ssl
@@ -8,16 +9,16 @@ import time
 import typing
 import urllib.parse
 import weakref
-from collections.abc import AsyncGenerator, Callable
+from collections.abc import AsyncGenerator, AsyncIterable, Callable
 from contextlib import suppress
-from typing import TypeVar
+from typing import BinaryIO, TypeVar
 
 import grpclib.client
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
 from modal.config import logger
-from modal.exception import ExecTimeoutError, TimeoutError as ModalTimeoutError
+from modal.exception import AuthError, ExecTimeoutError, InternalError, ServiceError, TimeoutError as ModalTimeoutError
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
@@ -26,6 +27,17 @@ from .._utils.grpc_utils import ModalChannel, create_channel_config
 from .async_utils import aclosing, retry
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 
+STREAMING_STDIN_CHUNK_SIZE = 256 * 1024
+
+_STREAMING_STDIN_RESUMABLE_EXCEPTIONS = (
+    AuthError,
+    InternalError,
+    ServiceError,
+    StreamTerminatedError,
+    OSError,
+    asyncio.TimeoutError,
+)
+
 
 @retry(n_attempts=34, base_delay=1, max_delay=10, attempt_timeout=10, total_timeout=310)
 async def _connect_channel(channel: grpclib.client.Channel):
@@ -468,6 +480,118 @@ class TaskCommandRouterClient:
                 lambda: self._call_with_auth_retry(self._stub.TaskExecStdinWrite, request)
             )
 
+    async def exec_stdin_write_stream(
+        self,
+        task_id: str,
+        exec_id: str,
+        source: BinaryIO,
+        chunk_size: int = STREAMING_STDIN_CHUNK_SIZE,
+        max_resume_attempts: int = 9,
+    ) -> int:
+        """Stream `source` into the exec's stdin, with bounded resume on transient failures.
+
+        Streams the full contents of `source` in one client-streaming RPC and
+        closes stdin (EOF) on success. On a resumable error, queries
+        `exec_stdin_status` for the server's canonical offset, seeks `source`
+        to that point, and reopens the stream.
+
+        Args:
+            task_id: The task ID of the task running the exec'd command.
+            exec_id: The execution ID of the command to write to.
+            source: A seekable byte source (file, BytesIO, etc.).
+            chunk_size: Bytes per outbound message.
+            max_resume_attempts: Upper bound on resume retries before giving up.
+
+        Returns:
+            The total number of bytes streamed into the exec's stdin.
+        """
+        offset = 0
+        attempt = 0
+        while True:
+
+            async def _chunks():
+                while True:
+                    chunk = source.read(chunk_size)
+                    if not chunk:
+                        return
+                    yield chunk
+
+            try:
+                source.seek(offset)
+                await self._exec_stdin_write_stream(task_id, exec_id, offset, _chunks())
+                return source.tell()
+            except (*_STREAMING_STDIN_RESUMABLE_EXCEPTIONS, AttributeError) as e:
+                # StreamTerminatedError surfaces as AttributeError in grpclib<=0.4.7;
+                # see call_with_retries_on_transient_errors.
+                if isinstance(e, AttributeError) and "_write_appdata" not in str(e):
+                    raise
+                attempt += 1
+                if attempt > max_resume_attempts:
+                    raise
+                status = await self.exec_stdin_status(task_id=task_id, exec_id=exec_id)
+                if status.closed:
+                    pos = source.tell()
+                    if status.num_bytes_written == pos and source.seek(0, io.SEEK_END) == pos:
+                        logger.debug(f"exec_stdin_write_stream completed but response was lost: {e}")
+                        return pos
+                    raise
+                offset = status.num_bytes_written
+                logger.debug(f"exec_stdin_write_stream resuming from offset {offset} after error: {e}")
+
+    async def _exec_stdin_write_stream(
+        self,
+        task_id: str,
+        exec_id: str,
+        start_offset: int,
+        chunks: AsyncIterable[bytes],
+    ) -> sr_pb2.TaskExecStdinWriteStreamResponse | None:
+        """Single client-streaming attempt: Start, Data chunks, then End (EOF).
+
+        Does not retry; `exec_stdin_write_stream` owns resume.
+        """
+        with grpc_error_converter():
+            stream = self._stub.TaskExecStdinWriteStream.open(metadata=self._get_metadata())
+            async with stream as s:
+                start = sr_pb2.TaskExecStdinWriteStreamRequest(
+                    start=sr_pb2.TaskExecStdinWriteStreamStart(
+                        task_id=task_id,
+                        exec_id=exec_id,
+                        offset=start_offset,
+                    ),
+                )
+                await s.send_message(start)
+                async for data in chunks:
+                    if not data:
+                        continue
+                    await s.send_message(sr_pb2.TaskExecStdinWriteStreamRequest(data=data))
+                # The server closes stdin only on this explicit End message. A
+                # stream that breaks before it leaves stdin open for resume.
+                await s.send_message(
+                    sr_pb2.TaskExecStdinWriteStreamRequest(end=sr_pb2.TaskExecStdinWriteStreamEnd()),
+                    end=True,
+                )
+                return await s.recv_message()
+
+    async def exec_stdin_status(self, task_id: str, exec_id: str) -> sr_pb2.TaskExecStdinStatusResponse:
+        """Read the current stdin write status for an exec'd command, to support retries from the right offset.
+
+        Used by streaming clients to find the resume offset after a stream
+        failure. Evicts any in-flight stdin stream for the exec, so it is not
+        safe to call for read-only observability.
+
+        Args:
+            task_id: The task ID of the task running the exec'd command.
+            exec_id: The execution ID of the command to query.
+        Raises:
+            Other errors: If retries are exhausted on transient errors or if there's an error
+              from the RPC itself.
+        """
+        request = sr_pb2.TaskExecStdinStatusRequest(task_id=task_id, exec_id=exec_id)
+        with grpc_error_converter():
+            return await call_with_retries_on_transient_errors(
+                lambda: self._call_with_auth_retry(self._stub.TaskExecStdinStatus, request)
+            )
+
     async def sandbox_stdin_write_v2(
         self, task_id: str, offset: int, data: bytes, eof: bool
     ) -> sr_pb2.SandboxStdinWriteV2Response:

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/_workspace.py

@@ -35,9 +35,7 @@ def _member_role_from_proto(proto_value: int) -> str:
 
 
 class _WorkspaceMembersManager:
-    """mdmd:namespace
-    Namespace with methods for managing the membership of a Workspace.
-    """
+    """mdmd:namespace"""
 
     def __init__(self, workspace: "_Workspace"):
         """mdmd:hidden"""
@@ -81,6 +79,7 @@ class _Workspace(_Object, type_prefix="ac"):
 
     @property
     def members(self) -> "_WorkspaceMembersManager":
+        """Namespace with methods for managing the membership of a Workspace."""
         return _WorkspaceMembersManager(self)
 
     @staticmethod
@@ -110,23 +109,25 @@ class _Workspace(_Object, type_prefix="ac"):
 
     @property
     def billing(self) -> "_WorkspaceBillingManager":
+        """Namespace for Workspace billing APIs."""
         return _WorkspaceBillingManager(self)
 
     @property
     def proxy_tokens(self) -> "_WorkspaceProxyTokenManager":
+        """Namespace with methods for managing the proxy tokens in a Workspace.
+
+        See [the guide](https://modal.com/docs/guide/webhook-proxy-auth) for more information on proxy tokens.
+        """
         return _WorkspaceProxyTokenManager(self)
 
     @property
     def settings(self) -> "_WorkspaceSettingsManager":
+        """Namespace for Workspace settings APIs."""
         return _WorkspaceSettingsManager(self)
 
 
 class _WorkspaceProxyTokenManager:
-    """mdmd:namespace
-    Namespace with methods for managing the proxy tokens in a Workspace.
-
-    See [the guide](https://modal.com/docs/guide/webhook-proxy-auth) for more information on proxy tokens.
-    """
+    """mdmd:namespace"""
 
     def __init__(self, workspace: "_Workspace"):
         """mdmd:hidden"""
@@ -245,9 +246,7 @@ class _WorkspaceProxyTokenManager:
 
 
 class _WorkspaceBillingManager:
-    """mdmd:namespace
-    Namespace for Workspace billing APIs.
-    """
+    """mdmd:namespace"""
 
     def __init__(self, workspace: _Workspace):
         """mdmd:hidden"""
@@ -321,9 +320,7 @@ class _WorkspaceBillingManager:
 
 
 class _WorkspaceSettingsManager:
-    """mdmd:namespace
-    Namespace for Workspace settings APIs.
-    """
+    """mdmd:namespace"""
 
     @classmethod
     def valid_settings(cls):

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/cli/shell.py

@@ -236,6 +236,7 @@ def _start_shell_from_image(
     region: str | None,
     pty: bool,
     experimental_options: dict[str, str],
+    v2: bool,
 ) -> None:
     volumes = {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
     secrets = [Secret.from_name(s) for s in secret]
@@ -267,6 +268,7 @@ def _start_shell_from_image(
         region=region.split(",") if region else [],
         pty=pty,
         experimental_options=experimental_options,
+        v2=v2,
     )
 
 
@@ -327,6 +329,14 @@ def _start_shell_from_image(
     hidden=True,
     metavar="KEY=VALUE",
 )
+@click.option(
+    "--experimental-v2",
+    "v2",
+    is_flag=True,
+    default=False,
+    hidden=True,
+    help="Create the shell using the V2 sandbox backend.",
+)
 def shell(
     ref: str | None = None,
     cmd: str = "/bin/bash",
@@ -344,6 +354,7 @@ def shell(
     pty: bool | None = None,
     use_module_mode: bool = False,
     experimental_options: tuple[str, ...] = (),
+    v2: bool = False,
 ):
     """Run a command or interactive shell inside a Modal container.
 
@@ -423,13 +434,20 @@ def shell(
             shell.params,
             ctx,
             locals(),
-            allowed=lambda p: p in {"cmd", "env", "pty", "ref", "use_module_mode", "experimental_options"},
+            allowed=lambda p: p in {"cmd", "env", "pty", "ref", "use_module_mode", "experimental_options", "v2"},
         ):
             raise ClickException(
                 f"Cannot specify container configuration arguments ({', '.join(passed_forbidden)}) "
                 f"when starting a new container from a function reference ('{ref}')."
             )
 
+        if v2:
+            # Function specs always carry mounts (e.g. the client mount), which the
+            # V2 backend does not support.
+            raise ClickException(
+                "--experimental-v2 is not supported when starting a shell from a function reference. "
+                "Use an image instead (e.g. `modal shell --experimental-v2 --image ...`)."
+            )
         function_spec = _function_spec_from_ref(ref, use_module_mode)
         _start_shell_from_function_spec(app, cmds, env, timeout, function_spec, pty, parsed_experimental_options)
         return
@@ -463,4 +481,5 @@ def shell(
         region,
         pty,
         parsed_experimental_options,
+        v2,
     )

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/client.pyi

@@ -37,7 +37,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.3.dev5",
+        version: str = "1.5.3.dev7",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -207,7 +207,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.3.dev5",
+        version: str = "1.5.3.dev7",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/container_process.py

@@ -1,7 +1,7 @@
 # Copyright Modal Labs 2024
 import asyncio
 import platform
-from typing import Generic, TypeVar
+from typing import BinaryIO, Generic, TypeVar
 
 from modal_proto import api_pb2
 
@@ -117,6 +117,18 @@ class _ContainerProcess(Generic[T]):
             )
         return self._returncode
 
+    async def _stdin_write_stream(self, source: BinaryIO) -> int:
+        """mdmd:hidden
+        Stream `source` into the process's stdin and close it (EOF) on success.
+
+        Returns the total bytes streamed.
+        """
+        return await self._command_router_client.exec_stdin_write_stream(
+            task_id=self._task_id,
+            exec_id=self._process_id,
+            source=source,
+        )
+
     async def poll(self) -> int | None:
         """Check if the container process has finished running.
 

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/container_process.pyi

@@ -53,6 +53,14 @@ class _ContainerProcess(typing.Generic[T]):
 
     @property
     def returncode(self) -> int: ...
+    async def _stdin_write_stream(self, source: typing.BinaryIO) -> int:
+        """mdmd:hidden
+        Stream `source` into the process's stdin and close it (EOF) on success.
+
+        Returns the total bytes streamed.
+        """
+        ...
+
     async def poll(self) -> typing.Optional[int]:
         """Check if the container process has finished running.
 
@@ -105,6 +113,25 @@ class ContainerProcess(typing.Generic[T]):
     @property
     def returncode(self) -> int: ...
 
+    class ___stdin_write_stream_spec(typing_extensions.Protocol):
+        def __call__(self, /, source: typing.BinaryIO) -> int:
+            """mdmd:hidden
+            Stream `source` into the process's stdin and close it (EOF) on success.
+
+            Returns the total bytes streamed.
+            """
+            ...
+
+        async def aio(self, /, source: typing.BinaryIO) -> int:
+            """mdmd:hidden
+            Stream `source` into the process's stdin and close it (EOF) on success.
+
+            Returns the total bytes streamed.
+            """
+            ...
+
+    _stdin_write_stream: ___stdin_write_stream_spec
+
     class __poll_spec(typing_extensions.Protocol):
         def __call__(self, /) -> typing.Optional[int]:
             """Check if the container process has finished running.

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/environments.pyi

@@ -102,11 +102,7 @@ class EnvironmentManager:
     delete: __delete_spec
 
 class EnvironmentMembersManager:
-    """mdmd:namespace
-    Namespace with methods for managing the membership of a restricted Environment.
-
-    See https://modal.com/docs/guide/rbac for more information on restricted Environments.
-    """
+    """mdmd:namespace"""
     def __init__(self, environment: Environment):
         """mdmd:hidden"""
         ...
@@ -254,9 +250,7 @@ class EnvironmentMembersManager:
     _dispatch_role_updates: ___dispatch_role_updates_spec
 
 class EnvironmentBillingManager:
-    """mdmd:namespace
-    Namespace for Environment billing APIs
-    """
+    """mdmd:namespace"""
     def __init__(self, environment: Environment):
         """mdmd:ignore"""
         ...
@@ -352,7 +346,13 @@ class Environment(modal.object.Object):
     @classmethod
     def objects(cls) -> EnvironmentManager: ...
     @property
-    def members(self) -> EnvironmentMembersManager: ...
+    def members(self) -> EnvironmentMembersManager:
+        """Namespace with methods for managing the membership of a restricted Environment.
+
+        See https://modal.com/docs/guide/rbac for more information on restricted Environments.
+        """
+        ...
+
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     @staticmethod
     def _get_or_create(
@@ -378,7 +378,9 @@ class Environment(modal.object.Object):
         ...
 
     @property
-    def billing(self) -> EnvironmentBillingManager: ...
+    def billing(self) -> EnvironmentBillingManager:
+        """Namespace for Environment billing APIs."""
+        ...
 
 class __create_environment_spec(typing_extensions.Protocol):
     def __call__(self, /, name: str, client: typing.Optional[modal.client.Client] = None): ...

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/functions.pyi

@@ -1044,11 +1044,13 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     class __get_call_graph_spec(typing_extensions.Protocol):
         def __call__(self, /) -> list[modal.types.InputInfo]:
-            """Returns a structure representing the call graph from a given root
-            call ID, along with the status of execution for each node.
+            """Fetch information about the graph of Inputs this FunctionCall is part of.
 
-            See [`modal.call_graph`](https://modal.com/docs/sdk/py/latest/modal.call_graph) reference page
-            for documentation on the structure of the returned `InputInfo` items.
+            Note: the call graph data is not populated in real-time, and its capture is best-effort.
+            We do not recommend relying on this method for critical use cases.
+
+            See the [`modal.types`](/docs/sdk/py/latest/modal.types) reference for information
+            on the return values.
 
             Returns:
                 A list of `InputInfo` nodes describing the call graph.
@@ -1056,11 +1058,13 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
             ...
 
         async def aio(self, /) -> list[modal.types.InputInfo]:
-            """Returns a structure representing the call graph from a given root
-            call ID, along with the status of execution for each node.
+            """Fetch information about the graph of Inputs this FunctionCall is part of.
+
+            Note: the call graph data is not populated in real-time, and its capture is best-effort.
+            We do not recommend relying on this method for critical use cases.
 
-            See [`modal.call_graph`](https://modal.com/docs/sdk/py/latest/modal.call_graph) reference page
-            for documentation on the structure of the returned `InputInfo` items.
+            See the [`modal.types`](/docs/sdk/py/latest/modal.types) reference for information
+            on the return values.
 
             Returns:
                 A list of `InputInfo` nodes describing the call graph.
@@ -1071,26 +1075,22 @@ class FunctionCall(typing.Generic[modal._functions.ReturnType], modal.object.Obj
 
     class __cancel_spec(typing_extensions.Protocol):
         def __call__(self, /, terminate_containers: bool = False):
-            """Cancels the function call, which will stop its execution and mark its inputs as
-            [`TERMINATED`](https://modal.com/docs/sdk/py/latest/modal.call_graph#modalcall_graphinputstatus).
-
-            If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-            causing any non-cancelled inputs on those containers to be rescheduled in new containers.
+            """Cancel the FunctionCall and terminate its inputs without retrying.
 
             Args:
-                terminate_containers: If True, forcibly terminate workers running cancelled inputs.
+                terminate_containers: If True, terminate the containers running the cancelled
+                    inputs. Any other inputs running concurrently on those containers will be
+                    rescheduled.
             """
             ...
 
         async def aio(self, /, terminate_containers: bool = False):
-            """Cancels the function call, which will stop its execution and mark its inputs as
-            [`TERMINATED`](https://modal.com/docs/sdk/py/latest/modal.call_graph#modalcall_graphinputstatus).
-
-            If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
-            causing any non-cancelled inputs on those containers to be rescheduled in new containers.
+            """Cancel the FunctionCall and terminate its inputs without retrying.
 
             Args:
-                terminate_containers: If True, forcibly terminate workers running cancelled inputs.
+                terminate_containers: If True, terminate the containers running the cancelled
+                    inputs. Any other inputs running concurrently on those containers will be
+                    rescheduled.
             """
             ...
 

{modal-1.5.3.dev5 → modal-1.5.3.dev7}/modal/runner.py

@@ -690,7 +690,12 @@ async def _deploy_app(
 
 
 async def _interactive_shell(
-    _app: "modal.app._App", cmds: list[str], environment_name: str = "", pty: bool = True, **kwargs: Any
+    _app: "modal.app._App",
+    cmds: list[str],
+    environment_name: str = "",
+    pty: bool = True,
+    v2: bool = False,
+    **kwargs: Any,
 ) -> None:
     """Run an interactive shell (like `bash`) within the image for this app.
 
@@ -732,13 +737,25 @@ async def _interactive_shell(
 
         # Temporarily enable output to show image build logs during sandbox creation
         output_mgr.set_quiet_mode(False)
-        sandbox = await _Sandbox._create(
-            "sleep",
-            "100000",
-            app=_app,
-            secrets=secrets,
-            **kwargs,
-        )
+        if v2:
+            for option in ("gpu", "mounts", "network_file_systems"):
+                if kwargs.pop(option, None):
+                    raise InvalidError(f"`{option}` is not supported for V2 sandboxes")
+            sandbox = await _Sandbox._experimental_create(
+                "sleep",
+                "100000",
+                app=_app,
+                secrets=secrets,
+                **kwargs,
+            )
+        else:
+            sandbox = await _Sandbox._create(
+                "sleep",
+                "100000",
+                app=_app,
+                secrets=secrets,
+                **kwargs,
+            )
 
         # Re-enable quiet mode before starting the interactive session
         output_mgr.set_quiet_mode(True)
@@ -757,7 +774,12 @@ async def _interactive_shell(
         except InteractiveTimeoutError:
             # Check on status of Sandbox. It may have crashed, causing connection failure.
             req = api_pb2.SandboxWaitRequest(sandbox_id=sandbox._object_id, timeout=0)
-            resp = await sandbox._client.stub.SandboxWait(req)
+            if v2:
+                assert sandbox._client._auth_token_manager
+                auth_token = await sandbox._client._auth_token_manager.get_token()
+                resp = await sandbox._client.stub.SandboxWaitV2(req, metadata=[("x-modal-auth-token", auth_token)])
+            else:
+                resp = await sandbox._client.stub.SandboxWait(req)
             if resp.result.exception:
                 raise RemoteError(resp.result.exception)
             else: