modal 1.4.4.dev17__tar.gz → 1.4.4.dev18__tar.gz

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/PKG-INFO

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

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/_container_entrypoint.py

@@ -28,7 +28,7 @@ from modal._clustered_functions import initialize_clustered_function
 from modal._runtime.user_code_event_loop import UserCodeEventLoop
 from modal._serialization import deserialize, deserialize_params
 from modal._utils.async_utils import TaskContext, aclosing, synchronizer
-from modal.app import App, _App
+from modal.app import _App
 from modal.client import Client, _Client
 from modal.config import logger
 from modal.exception import ExecutionError, InputCancellation
@@ -288,7 +288,7 @@ def get_serialized_user_class_and_function(
 
 
 def get_server_service(
-    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client
 ) -> Service:
     ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
     service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
@@ -298,14 +298,14 @@ def get_server_service(
     service = import_server_service(
         function_def,
         service_function_hydration_data,
-        client,
+        _client,
         ser_usr_cls,
     )
     return service
 
 
 def get_class_service(
-    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client
 ) -> Service:
     ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
     if container_args.serialized_params:
@@ -326,7 +326,7 @@ def get_class_service(
         function_def,
         service_function_hydration_data,
         class_id,
-        client,
+        _client,
         ser_usr_cls,
         param_args,
         param_kwargs,
@@ -349,16 +349,15 @@ def hydrate_function(
     task_lifecycle_manager: TaskLifecycleManager,
     function_def: api_pb2.Function,
     _client: _Client,
-    client: Client,
 ) -> Service:
     active_app: _App
     service: Service
     with task_lifecycle_manager.handle_task_lifecycle_exception():
         with execution_context._import_context():
             if function_def.is_server:
-                service = get_server_service(container_args, function_def, _client, client)
+                service = get_server_service(container_args, function_def, _client)
             elif function_def.is_class:
-                service = get_class_service(container_args, function_def, _client, client)
+                service = get_class_service(container_args, function_def, _client)
             else:
                 service = get_function_service(function_def, _client)
 
@@ -369,8 +368,7 @@ def hydrate_function(
 
     # Initialize objects on the app.
     # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-    app: App = cast(App, synchronizer._translate_out(active_app))
-    app._init_container(client, container_app)
+    active_app._init_container(_client, container_app)
 
     # Hydrate all function dependencies.
     # TODO(erikbern): we an remove this once we
@@ -406,7 +404,7 @@ def run_server(container_args: api_pb2.ContainerArguments, client: Client):
         client,
     )
 
-    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client, client)
+    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client)
     # Initialize clustered functions.
     if function_def._experimental_group_size > 0:
         initialize_clustered_function(
@@ -442,7 +440,7 @@ def run_function(container_args: api_pb2.ContainerArguments, client: Client):
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
         # Initialize the function, importing user code.
         service: Service = hydrate_function(
-            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client, client
+            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client
         )
         if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
             # Concurrency and batching doesn't apply for `modal shell`.

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/_function_variants.py

@@ -185,6 +185,48 @@ class _FunctionOptions:
         )
 
 
+async def _function_bind_params_cached(
+    base_function: "_Function",
+    req: api_pb2.FunctionBindParamsRequest,
+) -> api_pb2.FunctionBindParamsResponse:
+    """Cache layer for FunctionBindParams RPCs, scoped to a base Function handle.
+
+    We have this because users probably do not realize that Function invocations structured as
+
+        res = f.with_options(...).remote(...)
+
+    would always need to do two sequential RPCs (bind params / call function variant).
+
+    The bound Function ID from FunctionBindParams is deterministic with respect to the full request,
+    so we can avoid the unnecessary call and hydrate the new instance from a cached response.
+
+    The cache is stored on the base Function handle so that the variant cache behaves similarly to
+    the local reference to the base Function metadata.
+
+    """
+    cache = base_function._bind_params_cache
+    cache_key = req.SerializeToString(deterministic=True)
+
+    cached_response = cache.get(cache_key)
+    if cached_response is not None:
+        cache.move_to_end(cache_key)
+        response = api_pb2.FunctionBindParamsResponse()
+        response.ParseFromString(cached_response)
+        return response
+
+    assert base_function._client and base_function._client.stub
+    response = await base_function._client.stub.FunctionBindParams(req)
+
+    cache[cache_key] = response.SerializeToString(deterministic=True)
+    cache.move_to_end(cache_key)
+
+    max_cache_size = 32
+    while len(cache) > max_cache_size:
+        cache.popitem(last=False)
+
+    return response
+
+
 def _make_function_variant(
     base_function: "_Function",
     options: _FunctionOptions | None,
@@ -229,7 +271,7 @@ def _make_function_variant(
             or "",  # TODO: investigate shouldn't environment name always be specified here?
         )
 
-        response = await base_function._client.stub.FunctionBindParams(req)
+        response = await _function_bind_params_cached(base_function, req)
         function_variant._hydrate(response.bound_function_id, base_function._client, response.handle_metadata)
 
     def _deps():

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/_functions.py

@@ -5,6 +5,7 @@ import inspect
 import time
 import typing
 import warnings
+from collections import OrderedDict
 from collections.abc import AsyncGenerator, AsyncIterator, Callable, Collection, Sequence
 from dataclasses import dataclass
 from pathlib import PurePosixPath
@@ -1354,6 +1355,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._options = _FunctionOptions()
         self._base_function = None
 
+        # An OrderedDict[bytes, bytes] LRU of FunctionBindParams responses for
+        # variants derived from this base Function. Omitted from class-level annotations because
+        # Synchronicity doesn't understand OrderedDict as a type hint.
+        self._bind_params_cache = OrderedDict()
+
     def _hydrate_metadata(self, metadata: Message | None):
         # Overridden concrete implementation of base class method
         assert metadata and isinstance(metadata, api_pb2.FunctionHandleMetadata), (
@@ -1382,6 +1388,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         )
         self._experimental_flash_urls = metadata._experimental_flash_urls
 
+        # Invalidate the Function variant cache when we load new metadata, since the base Function handle
+        # is now in sync with the server but any previously-cached variants may be stale.
+        self._bind_params_cache.clear()
+
     def _get_metadata(self):
         # Overridden concrete implementation of base class method
         assert self._function_name, f"Function name must be set before metadata can be retrieved for {self}"

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/_runtime/user_code_imports.py

@@ -571,7 +571,7 @@ def import_class_service(
     function_def: api_pb2.Function,
     service_function_hydration_data: api_pb2.Object,
     class_id: str,
-    client: "modal.client.Client",
+    _client: "modal.client._Client",
     ser_user_cls: type | None,
     cls_args,
     cls_kwargs,
@@ -599,7 +599,6 @@ def import_class_service(
         # Undecorated user class (serialized or local scope-decoration).
         service_deps = None  # we can't infer service deps for now
         active_app = get_active_app_fallback(function_def)
-        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
         _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
             service_function_hydration_data.object_id,
             _client,
@@ -627,7 +626,7 @@ def import_class_service(
 def import_server_service(
     function_def: api_pb2.Function,
     service_function_hydration_data: api_pb2.Object,
-    client: "modal.client.Client",
+    _client: "modal.client._Client",
     ser_user_cls: type | None,
 ) -> Service:
     """
@@ -654,7 +653,6 @@ def import_server_service(
         # Undecorated user class (serialized or local scope-decoration).
         service_deps = None  # we can't infer service deps for now
         active_app = get_active_app_fallback(function_def)
-        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
         _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
             service_function_hydration_data.object_id,
             _client,

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/_utils/sandbox_fs_utils.py

@@ -285,6 +285,53 @@ def make_stat_command(remote_path: str) -> str:
     return json.dumps({"Stat": {"path": remote_path}})
 
 
+def raise_watch_error(returncode: int, stderr: str | bytes, remote_path: str) -> NoReturn:
+    if payload := try_parse_error_payload(stderr):
+        logger.debug(
+            f"sandbox-fs-tools watch error: path={remote_path}, "
+            f"error_kind={payload.error_kind}, message={payload.message}, detail={payload.detail}"
+        )
+        if payload.error_kind == "NotFound":
+            raise SandboxFilesystemNotFoundError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "PermissionDenied":
+            raise SandboxFilesystemPermissionError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "NotSupported":
+            raise InvalidError(
+                f"{payload.message}: {remote_path} - this operation is not supported for CloudBucketMounts"
+            )
+        raise SandboxFilesystemError(payload.message)
+
+    if stderr_text := _stderr_to_text(stderr):
+        logger.debug(f"Unstructured modal-sandbox-fs-tools stderr: {stderr_text}")
+    raise SandboxFilesystemError(f"Operation on '{remote_path}' failed with exit code {returncode}")
+
+
+def make_watch_command(
+    remote_path: str,
+    *,
+    recursive: bool,
+    filter: list[str] | None,
+    timeout: int | None,
+) -> str:
+    """Build the JSON command string for a Watch operation.
+
+    The returned JSON must match the `Command` enum in the modal-sandbox-fs-tools
+    Rust crate (crates/modal-sandbox-fs-tools/src/lib.rs). Treat changes to
+    this schema like protobuf changes: fields must not be removed or renamed,
+    only added with backwards-compatible defaults.
+    """
+    return json.dumps(
+        {
+            "Watch": {
+                "path": remote_path,
+                "recursive": recursive,
+                "filter": filter,
+                "timeout_secs": timeout,
+            }
+        }
+    )
+
+
 def validate_absolute_remote_path(remote_path: str, operation: str) -> None:
     if not PurePosixPath(remote_path).is_absolute():
         raise InvalidError(f"Sandbox.filesystem.{operation}() currently only supports absolute remote_path values")

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/billing.py

@@ -3,4 +3,8 @@ from ._billing import WorkspaceBillingReportItem, _workspace_billing_report
 from ._utils.async_utils import synchronize_api
 
 workspace_billing_report = synchronize_api(_workspace_billing_report)
-assert WorkspaceBillingReportItem
+
+__all__ = [
+    "workspace_billing_report",
+    "WorkspaceBillingReportItem",
+]

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.4.dev17",
+        version: str = "1.4.4.dev18",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -205,7 +205,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.4.dev17",
+        version: str = "1.4.4.dev18",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/file_io.py

@@ -1,10 +1,8 @@
 # Copyright Modal Labs 2024
 import asyncio
-import enum
 import io
 from collections.abc import AsyncIterator, Sequence
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar, Union, cast
 
 if TYPE_CHECKING:
     import _typeshed
@@ -15,6 +13,7 @@ from grpclib.exceptions import StreamTerminatedError
 
 from modal._utils.async_utils import TaskContext
 from modal.exception import ClientClosed
+from modal.sandbox_fs import FileWatchEvent, FileWatchEventType
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
@@ -60,21 +59,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: int | None = None,
     deprecation_error((2025, 12, 3), "replace_bytes has been removed.")
 
 
-class FileWatchEventType(enum.Enum):
-    Unknown = "Unknown"
-    Access = "Access"
-    Create = "Create"
-    Modify = "Modify"
-    Remove = "Remove"
-
-
-@dataclass
-class FileWatchEvent:
-    paths: list[str]
-    type: FileWatchEventType
-
-
-async def _consume_output(client: _Client, exec_id: str) -> AsyncIterator[bytes | None | Exception]:
+async def _consume_output(client: _Client, exec_id: str) -> AsyncIterator[Optional[bytes] | Exception]:
     req = api_pb2.ContainerFilesystemExecGetOutputRequest(
         exec_id=exec_id,
         timeout=55,
@@ -424,7 +409,7 @@ class _FileIO(Generic[T]):
     ) -> AsyncIterator[FileWatchEvent]:
         deprecation_warning(
             (2026, 3, 9),
-            "`FileIO.watch()` is deprecated. Use `Sandbox.watch()` instead.",
+            "`FileIO.watch()` is deprecated. Use `Sandbox.filesystem.watch()` instead.",
         )
         async for event in watch(path, client, task_id, filter, recursive, timeout):
             yield event

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/file_io.pyi

@@ -1,8 +1,8 @@
 import _io
 import _typeshed
 import collections.abc
-import enum
 import modal.client
+import modal.sandbox_fs
 import typing
 import typing_extensions
 
@@ -22,31 +22,6 @@ async def _replace_bytes(
     """
     ...
 
-class FileWatchEventType(enum.Enum):
-    Unknown = "Unknown"
-    Access = "Access"
-    Create = "Create"
-    Modify = "Modify"
-    Remove = "Remove"
-
-class FileWatchEvent:
-    """FileWatchEvent(paths: list[str], type: modal.file_io.FileWatchEventType)"""
-
-    paths: list[str]
-    type: FileWatchEventType
-
-    def __init__(self, paths: list[str], type: FileWatchEventType) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def __repr__(self):
-        """Return repr(self)."""
-        ...
-
-    def __eq__(self, other):
-        """Return self==value."""
-        ...
-
 def _consume_output(
     client: modal.client._Client, exec_id: str
 ) -> collections.abc.AsyncIterator[typing.Union[bytes, None, Exception]]: ...
@@ -157,10 +132,10 @@ class _FileIO(typing.Generic[T]):
         path: str,
         client: modal.client._Client,
         task_id: str,
-        filter: typing.Optional[list[FileWatchEventType]] = None,
+        filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
         recursive: bool = False,
         timeout: typing.Optional[int] = None,
-    ) -> collections.abc.AsyncIterator[FileWatchEvent]: ...
+    ) -> collections.abc.AsyncIterator[modal.sandbox_fs.FileWatchEvent]: ...
     async def _close(self) -> None: ...
     async def close(self) -> None:
         """Flush the buffer and close the file."""
@@ -190,10 +165,10 @@ def watch(
     path: str,
     client: modal.client._Client,
     task_id: str,
-    filter: typing.Optional[list[FileWatchEventType]] = None,
+    filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
     recursive: bool = False,
     timeout: typing.Optional[int] = None,
-) -> collections.abc.AsyncIterator[FileWatchEvent]:
+) -> collections.abc.AsyncIterator[modal.sandbox_fs.FileWatchEvent]:
     """Watch a file or directory for changes."""
     ...
 
@@ -428,20 +403,20 @@ class FileIO(typing.Generic[T]):
             path: str,
             client: modal.client.Client,
             task_id: str,
-            filter: typing.Optional[list[FileWatchEventType]] = None,
+            filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
             recursive: bool = False,
             timeout: typing.Optional[int] = None,
-        ) -> typing.Iterator[FileWatchEvent]: ...
+        ) -> typing.Iterator[modal.sandbox_fs.FileWatchEvent]: ...
         def aio(
             self,
             /,
             path: str,
             client: modal.client.Client,
             task_id: str,
-            filter: typing.Optional[list[FileWatchEventType]] = None,
+            filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
             recursive: bool = False,
             timeout: typing.Optional[int] = None,
-        ) -> collections.abc.AsyncIterator[FileWatchEvent]: ...
+        ) -> collections.abc.AsyncIterator[modal.sandbox_fs.FileWatchEvent]: ...
 
     watch: typing.ClassVar[__watch_spec]
 

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/functions.pyi

@@ -465,7 +465,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result.
 
@@ -490,7 +490,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -540,7 +540,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -573,7 +573,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -581,7 +581,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -614,7 +614,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.

{modal-1.4.4.dev17 → modal-1.4.4.dev18}/modal/sandbox.py

@@ -1953,7 +1953,7 @@ class _Sandbox(_Object, type_prefix="sb"):
     ):
         """[Alpha] Open a file in the Sandbox and return a FileIO handle.
 
-        **Deprecated (2026-03-09):** Use the `Sandbox.filesystem` APIs instead.
+        **Deprecated (2026-03-09):** Use the `Sandbox.filesystem` APIs instead for improved reliability.
 
         See the [`FileIO`](https://modal.com/docs/reference/modal.file_io#modalfile_iofileio) docs for more information.
 
@@ -1975,7 +1975,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         self._ensure_v1("open")
         deprecation_warning(
             (2026, 3, 9),
-            "`Sandbox.open()` is deprecated. Use the `Sandbox.filesystem` APIs instead.",
+            "`Sandbox.open()` is deprecated. Use the `Sandbox.filesystem` APIs instead for improved reliability.",
         )
         task_id = await self._get_task_id()
         return await _FileIO.create(path, mode, self._client, task_id)
@@ -1983,7 +1983,7 @@ class _Sandbox(_Object, type_prefix="sb"):
     async def ls(self, path: str) -> builtins.list[str]:
         """[Alpha] List the contents of a directory in the Sandbox.
 
-        **Deprecated (2026-04-15):** Use `Sandbox.filesystem.list_files()` instead.
+        **Deprecated (2026-04-15):** Use `Sandbox.filesystem.list_files()` instead for improved reliability.
 
         Args:
             path: Absolute directory path inside the sandbox.
@@ -1994,7 +1994,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         self._ensure_v1("ls")
         deprecation_warning(
             (2026, 4, 15),
-            "`Sandbox.ls()` is deprecated. Use `Sandbox.filesystem.list_files()` instead.",
+            "`Sandbox.ls()` is deprecated. Use `Sandbox.filesystem.list_files()` instead for improved reliability.",
         )
         task_id = await self._get_task_id()
         return await ls(path, self._client, task_id)
@@ -2002,12 +2002,13 @@ class _Sandbox(_Object, type_prefix="sb"):
     async def mkdir(self, path: str, parents: bool = False) -> None:
         """[Alpha] Create a new directory in the Sandbox.
 
-        **Deprecated (2026-04-15):** Use `Sandbox.filesystem.make_directory()` instead.
+        **Deprecated (2026-04-15):** Use `Sandbox.filesystem.make_directory()` instead for improved reliability.
         """
         self._ensure_v1("mkdir")
         deprecation_warning(
             (2026, 4, 15),
-            "`Sandbox.mkdir()` is deprecated. Use `Sandbox.filesystem.make_directory()` instead.",
+            "`Sandbox.mkdir()` is deprecated. Use `Sandbox.filesystem.make_directory()` instead for improved "
+            "reliability.",
         )
         task_id = await self._get_task_id()
         return await mkdir(path, self._client, task_id, parents)
@@ -2015,12 +2016,12 @@ class _Sandbox(_Object, type_prefix="sb"):
     async def rm(self, path: str, recursive: bool = False) -> None:
         """[Alpha] Remove a file or directory in the Sandbox.
 
-        **Deprecated (2026-04-15):** Use `Sandbox.filesystem.remove()` instead.
+        **Deprecated (2026-04-15):** Use `Sandbox.filesystem.remove()` instead for improved reliability.
         """
         self._ensure_v1("rm")
         deprecation_warning(
             (2026, 4, 15),
-            "`Sandbox.rm()` is deprecated. Use `Sandbox.filesystem.remove()` instead.",
+            "`Sandbox.rm()` is deprecated. Use `Sandbox.filesystem.remove()` instead for improved reliability.",
         )
         task_id = await self._get_task_id()
         return await rm(path, self._client, task_id, recursive)
@@ -2034,6 +2035,8 @@ class _Sandbox(_Object, type_prefix="sb"):
     ) -> AsyncIterator[FileWatchEvent]:
         """[Alpha] Watch a file or directory in the Sandbox for changes.
 
+        **Deprecated (2026-05-08):** Use `Sandbox.filesystem.watch()` instead for improved reliability.
+
         Args:
             path: Absolute path to watch.
             filter: Optional list of event types to include.
@@ -2044,6 +2047,10 @@ class _Sandbox(_Object, type_prefix="sb"):
             An async iterator of `FileWatchEvent` values.
         """
         self._ensure_v1("watch")
+        deprecation_warning(
+            (2026, 5, 8),
+            "`Sandbox.watch()` is deprecated. Use `Sandbox.filesystem.watch()` instead for improved reliability.",
+        )
         task_id = await self._get_task_id()
         async for event in watch(path, self._client, task_id, filter, recursive, timeout):
             yield event