modal 1.5.1.dev14__tar.gz → 1.5.1.dev15__tar.gz

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/PKG-INFO

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

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/_image.py

@@ -2965,17 +2965,16 @@ class _Image(_Object, type_prefix="im"):
         """
         tag = _parse_named_image_ref(name)
 
-        if not self.is_hydrated:
+        if self._object_id is None:
             raise InvalidError("Cannot publish an image that has not been created yet. Call `.build()` first.")
 
-        _client = client or self._client
-        assert _client is not None
+        _client = client or await _Client.from_env()
 
         resolved_env = environment_name or config.get("environment") or ""
 
         await _client.stub.ImagePublish(
             api_pb2.ImagePublishRequest(
-                image_id=self.object_id,
+                image_id=self._object_id,
                 environment_name=resolved_env,
                 is_public=False,
                 tag=tag,

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/_runtime/gpu_memory_snapshot.py

@@ -17,6 +17,11 @@ from modal.config import config, logger
 
 CUDA_CHECKPOINT_PATH: str = config.get("cuda_checkpoint_path")
 
+# Exit code used to signal to modal-runtime that a GPU memory snapshot restore failed
+# and the task should be retried without a snapshot. This is a sentinel value that must
+# stay in sync with `GPU_SNAPSHOT_RESTORE_FAILED_EXIT_CODE` in runner.rs.
+SNAPSHOT_RESTORE_FAILED_EXIT_CODE: int = 222
+
 # Maximum total duration for each individual `cuda-checkpoint` invocation.
 CUDA_CHECKPOINT_TIMEOUT: float = 3 * 60.0
 

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/_runtime/task_lifecycle_manager.py

@@ -180,10 +180,15 @@ class _TaskLifecycleManager:
         if self.function_def._experimental_enable_gpu_snapshot and self.function_def.resources.gpu_config.gpu_type:
             logger.debug("GPU memory snapshot enabled. Attempting to restore GPU memory.")
 
-            assert self._cuda_checkpoint_session, (
-                "CudaCheckpointSession not found when attempting to restore GPU memory"
-            )
-            self._cuda_checkpoint_session.restore()
+            try:
+                if self._cuda_checkpoint_session is None:
+                    raise gpu_memory_snapshot.CudaCheckpointException("CudaCheckpointSession not found")
+                self._cuda_checkpoint_session.restore()
+            except gpu_memory_snapshot.CudaCheckpointException as exc:
+                logger.warning(f"GPU memory snapshot restore failed; retrying task without snapshot. Error: {exc}")
+                sys.stderr.flush()
+                # Exit with a sentinel code that the runtime will use to retry the task without a snapshot.
+                os._exit(gpu_memory_snapshot.SNAPSHOT_RESTORE_FAILED_EXIT_CODE)
 
         self._client = await _Client.from_env()
 

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/_workspace.py

@@ -121,10 +121,154 @@ class _Workspace(_Object, type_prefix="ac"):
     def billing(self) -> "_WorkspaceBillingManager":
         return _WorkspaceBillingManager(self)
 
+    @property
+    def proxy_tokens(self) -> "_WorkspaceProxyTokenManager":
+        return _WorkspaceProxyTokenManager(self)
+
+
+@dataclass(frozen=True)
+class TokenData:
+    """A token ID / secret pair."""
+
+    token_id: str
+    token_secret: str
+
+
+@dataclass(frozen=True)
+class ProxyTokenInfo:
+    """Metadata about a proxy token, not including the token secret."""
+
+    token_id: str
+    created_at: datetime
+    scoped: bool
+
+
+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.
+    """
+
+    def __init__(self, workspace: "_Workspace"):
+        """mdmd:hidden"""
+        self._workspace = workspace
+
+    async def create(self) -> TokenData:
+        """Create a new proxy token for the Workspace.
+
+        Examples:
+            ```python notest
+            token = modal.Workspace.from_context().proxy_tokens.create()
+            print(token.token_id, token.token_secret)
+            ```
+        """
+        await self._workspace.hydrate()
+        resp = await self._workspace.client.stub.WebhookTokenCreate(api_pb2.WebhookTokenCreateRequest())
+        return TokenData(token_id=resp.token_id, token_secret=resp.token_secret)
+
+    async def list(self, environment_name: Optional[str] = None) -> builtins.list[ProxyTokenInfo]:
+        """List proxy tokens in the Workspace.
+
+        Args:
+            environment_name: When provided, list only the tokens associated with this environment.
+
+        Examples:
+            ```python notest
+            ws = modal.Workspace.from_context()
+
+            # List all proxy tokens in the Workspace
+            tokens = ws.proxy_tokens.list()
+            print([t.token_id for t in tokens])
+
+            # List only the proxy tokens associated with a specific Environment
+            env_tokens = ws.proxy_tokens.list(environment_name="prod")
+            ```
+        """
+        await self._workspace.hydrate()
+        if environment_name is None:
+            resp = await self._workspace.client.stub.WebhookTokenList(Empty())
+        else:
+            resp = await self._workspace.client.stub.WebhookTokenListForEnvironment(
+                api_pb2.WebhookTokenListForEnvironmentRequest(environment_name=environment_name)
+            )
+        return [
+            ProxyTokenInfo(
+                token_id=token.token_id,
+                created_at=timestamp_to_localized_dt(token.created_at),
+                scoped=token.scoped,
+            )
+            for token in resp.tokens
+        ]
+
+    async def allow(self, proxy_token_id: str, environment_name: str) -> None:
+        """Allow a proxy token to authenticate requests to a given Environment.
+
+        Args:
+            proxy_token_id: The token ID (`wk-...`) to operate on.
+            environment_name: The name of the environment to allow access to.
+
+        Examples:
+            ```python notest
+            ws = modal.Workspace.from_context()
+            token = ws.proxy_tokens.create()
+            ws.proxy_tokens.allow(token.token_id, "prod")
+            ```
+        """
+        await self._workspace.hydrate()
+        environment_id = await self._environment_id(environment_name)
+        req = api_pb2.WebhookTokenEnvironmentAddRequest(token_id=proxy_token_id, environment_id=environment_id)
+        await self._workspace.client.stub.WebhookTokenEnvironmentAdd(req)
+
+    async def revoke(self, proxy_token_id: str, environment_name: str) -> None:
+        """Revoke a proxy token's access to a given Environment.
+
+        The proxy token is not deleted, and it will continue to authenticate requests to any
+        other Environments it is associated with.
+
+        Args:
+            proxy_token_id: The token ID (`wk-...`) to operate on.
+            environment_name: The name of the environment to revoke access from.
+
+        Examples:
+            ```python notest
+            ws = modal.Workspace.from_context()
+            ws.proxy_tokens.revoke(token_id, "prod")
+            ```
+        """
+        await self._workspace.hydrate()
+        environment_id = await self._environment_id(environment_name)
+        req = api_pb2.WebhookTokenEnvironmentRemoveRequest(token_id=proxy_token_id, environment_id=environment_id)
+        await self._workspace.client.stub.WebhookTokenEnvironmentRemove(req)
+
+    async def delete(self, proxy_token_id: str) -> None:
+        """Delete a proxy token from the Workspace.
+
+        This cannot be reverted. Any clients currently using the token will immediately
+        lose access to associated resources.
+
+        Args:
+            proxy_token_id: The token ID (`wk-...`) to delete.
+
+        Examples:
+            ```python notest
+            modal.Workspace.from_context().proxy_tokens.delete(token_id)
+            ```
+        """
+        await self._workspace.hydrate()
+        await self._workspace.client.stub.WebhookTokenDelete(api_pb2.TokenDeleteRequest(token_id=proxy_token_id))
+
+    async def _environment_id(self, environment_name: str) -> str:
+        # The environment-association RPCs key on environment ID, so resolve the name first.
+        from ._environments import _Environment
+
+        environment = await _Environment.from_name(environment_name, client=self._workspace.client).hydrate()
+        return environment.object_id
+
 
 class _WorkspaceBillingManager:
     """mdmd:namespace
-    Namespace for Workspace billing APIs
+    Namespace for Workspace billing APIs.
     """
 
     def __init__(self, workspace: _Workspace):

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/cli/app.py

@@ -4,7 +4,7 @@ import sys
 import time
 import warnings
 from datetime import datetime, timedelta, timezone
-from typing import get_args
+from typing import Literal, get_args
 
 import click
 import rich
@@ -268,6 +268,7 @@ async def logs(
     ```
 
     """
+    env = ensure_env(env)
 
     if follow and (since or until or tail):
         raise UsageError("--follow cannot be combined with --since, --until, or --tail.")
@@ -353,11 +354,18 @@ async def logs(
 @app_cli.command("rollback", no_args_is_help=True, context_settings={"ignore_unknown_options": True})
 @click.argument("app_identifier")
 @click.argument("version", default="")
+@click.option(
+    "--strategy",
+    default="rolling",
+    type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE)),
+    help="Strategy for rollback",
+)
 @env_option
 @synchronizer.create_blocking
 async def rollback(
     app_identifier: str,
     version: str = "",
+    strategy: Literal["recreate", "rolling"] = "rolling",
     *,
     env: str | None = None,
 ):
@@ -403,8 +411,20 @@ async def rollback(
         else:
             raise UsageError(f"Invalid version specifier: {version}")
     req = api_pb2.AppRollbackRequest(app_id=app_id, version=version_number)
-    await client.stub.AppRollback(req)
-    rich.print("[green]✓[/green] Deployment rollback successful!")
+    resp = await client.stub.AppRollback(req)
+    print_server_warnings(resp.server_warnings)
+    output_mgr = OutputManager.get()
+    if strategy == "recreate":
+        try:
+            await _stop_and_wait_for_containers(client, app_id, resp.deployed_at, env)
+        except Exception as exc:
+            warnings.warn(
+                f"App rollback executed successfully, but containers did not all terminate. {exc}", UserWarning
+            )
+            output_mgr.print(f"\nView Deployment: [magenta]{resp.url}[/magenta]")
+            sys.exit(1)
+    output_mgr.print("[green]✓[/green] Deployment rollback successful!")
+    output_mgr.print(f"\nView Deployment: [magenta]{resp.url}[/magenta]")
 
 
 @app_cli.command("rollover", no_args_is_help=True)
@@ -626,6 +646,7 @@ async def dashboard(
     modal app dashboard my-app --env dev
     ```
     """
+    env = ensure_env(env)
     client = await _Client.from_env()
     app_id, _, _ = await resolve_app_identifier(app_identifier, env, client)
     url = f"https://modal.com/id/{app_id}"

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/cli/entry_point.py

@@ -29,6 +29,7 @@ from .secret import secret_cli
 from .skills import skills_cli
 from .token import _new_token, token_cli
 from .volume import volume_cli
+from .workspace import workspace_cli
 
 
 @click.group(
@@ -117,11 +118,12 @@ entrypoint_cli.add_command(volume_cli, panel="Storage")
 entrypoint_cli.add_command(setup, panel="Onboarding")
 entrypoint_cli.add_command(bootstrap, panel="Onboarding")
 
-entrypoint_cli.add_command(config_cli, panel="Configuration")
+entrypoint_cli.add_command(workspace_cli, panel="Configuration")
 entrypoint_cli.add_command(environment_cli, panel="Configuration")
 entrypoint_cli.add_command(profile_cli, panel="Configuration")
-entrypoint_cli.add_command(skills_cli, panel="Configuration")
+entrypoint_cli.add_command(config_cli, panel="Configuration")
 entrypoint_cli.add_command(token_cli, panel="Configuration")
+entrypoint_cli.add_command(skills_cli, panel="Configuration")
 
 entrypoint_cli.add_command(billing_cli, panel="Observability")
 entrypoint_cli.add_command(changelog, panel="Observability")

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/cli/environment.py

@@ -187,11 +187,10 @@ environment_cli.add_command(billing_cli)
 
 
 @billing_cli.command("report", no_args_is_help=True)
-@click.option(
-    "-n",
-    "--environment-name",
+@click.argument(
+    "environment_name",
+    required=False,
     default=None,
-    help="Name of the environment to build a report for. If no argument is provided, uses the current default.",
 )
 @click.option("--start", default=None, help=f"Start date. {DATE_HELP}")
 @click.option("--end", default=None, help=f"End date. {DATE_HELP} Defaults to now.")
@@ -244,19 +243,19 @@ async def environment_billing(
     Examples:
 
         ```bash
-        modal environment billing report -n env1 --start 2025-12-01 --end 2026-01-01
+        modal environment billing report --start 2025-12-01 --end 2026-01-01
 
-        modal environment billing report -n env2 --for "last month" --tag-names team,project
+        modal environment billing report --for "last month" --tag-names team,project
 
-        modal environment billing report -n test_env --for today --resolution h
+        modal environment billing report test_env --for today --resolution h
 
-        modal environment billing report -n test_env --for "this month" --show-resources
+        modal environment billing report test_env --for "this month" --show-resources
 
-        modal environment billing report -n prod_env --for yesterday -r h --tz local
+        modal environment billing report prod_env --for yesterday -r h --tz local
 
-        modal environment billing report -n main_env --for "last month" --csv > report.csv
+        modal environment billing report main_env --for "last month" --csv > report.csv
 
-        modal environment billing report -n main_env --start 2025-12-01 --json > report.json
+        modal environment billing report main_env --start 2025-12-01 --json > report.json
         ```
 
     """

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/cli/utils.py

@@ -123,7 +123,7 @@ async def fetch_app_logs(
     await _drain_batches(output_mgr, batches, prefix_fields or [], filters.search_text)
 
 
-def _plain(text: Text | str) -> str:
+def _plain(text: "Text | str | bool | None") -> "str | bool | None":
     return text.plain if isinstance(text, Text) else text
 
 
@@ -138,7 +138,7 @@ def is_tty() -> bool:
 
 def display_table(
     columns: Sequence[Column | str],
-    rows: Sequence[Sequence[Text | str]],
+    rows: Sequence[Sequence["Text | str | bool | None"]],
     json: bool = False,
     csv: bool = False,
     title: str = "",
@@ -164,7 +164,12 @@ def display_table(
     else:
         table = Table(*columns, title=title)
         for row in rows:
-            table.add_row(*row)
+            # rich can't render bare scalars like bools; stringify anything that isn't already
+            # a renderable (str/Text) or None (which rich treats as an empty cell).
+            cells: list[Text | str | None] = [
+                cell if cell is None or isinstance(cell, (str, Text)) else str(cell) for cell in row
+            ]
+            table.add_row(*cells)
         output.print(table)
 
 

modal-1.5.1.dev15/modal/cli/workspace.py

@@ -0,0 +1,129 @@
+# Copyright Modal Labs 2025
+import json as json_mod
+
+import click
+import rich
+
+from modal._utils.time_utils import timestamp_to_localized_str
+from modal.cli.utils import confirm_or_suggest_yes, display_table, yes_option
+from modal.output import OutputManager
+from modal.workspace import Workspace
+
+from ._help import ModalGroup
+
+WORKSPACE_HELP_TEXT = """Interact with the current Modal Workspace.
+
+A Workspace is the top-level account that owns your Modal resources. Use these commands
+to manage workspace-level settings such as proxy tokens.
+"""
+
+workspace_cli = ModalGroup(name="workspace", help=WORKSPACE_HELP_TEXT)
+
+
+MEMBERS_HELP_TEXT = """View the members of the current Workspace."""
+
+members_cli = ModalGroup(name="members", help=MEMBERS_HELP_TEXT)
+workspace_cli.add_command(members_cli)
+
+
+@members_cli.command("list", help="List the members of the current Workspace.")
+@click.option("--json", is_flag=True, default=False)
+def members_list(json: bool = False):
+    members = Workspace.from_context().members.list()
+    rows = [
+        [
+            member.name,
+            member.email,
+            member.role,
+            member.user_id,
+            timestamp_to_localized_str(member.joined_at.timestamp(), json),
+            timestamp_to_localized_str(member.last_active_at.timestamp(), json) if member.last_active_at else None,
+        ]
+        for member in members
+    ]
+    display_table(["Name", "Email", "Role", "User ID", "Joined", "Last active"], rows, json=json)
+
+
+PROXY_TOKENS_HELP_TEXT = """Manage the proxy tokens of the current Workspace.
+
+Proxy tokens provide authentication to HTTP interfaces on Modal Servers and Web Functions.
+They are passed as request headers (`Modal-Key` and `Modal-Secret`). See
+https://modal.com/docs/guide/webhook-proxy-auth for more information.
+
+Proxy tokens and secrets have `wk-` and `ws-` prefixes, respectively. The cannot be
+interchanged with API tokens (which use `ak-` and `as-` prefixes).
+
+On workspaces with RBAC enabled, tokens are scoped to specific environments;
+use the `allow` and `revoke` commands to manage environment associations.
+"""
+
+proxy_tokens_cli = ModalGroup(name="proxy-tokens", help=PROXY_TOKENS_HELP_TEXT)
+workspace_cli.add_command(proxy_tokens_cli)
+
+
+@proxy_tokens_cli.command("create", help="Create a proxy token in the current Workspace.")
+@click.option("--json", is_flag=True, default=False)
+def proxy_tokens_create(*, json: bool = False):
+    """Create a proxy token in the current Workspace.
+
+    The new token's ID and secret will be printed to stdout. The secret is only
+    shown at creation time and cannot be retrieved later.
+    """
+    token = Workspace.from_context().proxy_tokens.create()
+    output_manager = OutputManager.get()
+    if json:
+        output_manager.print_json(json_mod.dumps({"Modal-Key": token.token_id, "Modal-Secret": token.token_secret}))
+    else:
+        output_manager.print(f"Modal-Key: {token.token_id}\nModal-Secret: {token.token_secret}")
+
+
+@proxy_tokens_cli.command("list", help="List the proxy tokens of the current Workspace.")
+@click.option(
+    "-e",
+    "--environment",
+    default=None,
+    help="Only list tokens associated with this environment. Lists all tokens when omitted.",
+)
+@click.option("--json", is_flag=True, default=False)
+def proxy_tokens_list(environment: str | None = None, json: bool = False):
+    tokens = Workspace.from_context().proxy_tokens.list(environment_name=environment)
+    # Emit a real boolean for JSON output, but a string for the rich table (which can't render a bare bool).
+    rows = [
+        [
+            token.token_id,
+            timestamp_to_localized_str(token.created_at.timestamp(), json),
+            token.scoped if json else str(token.scoped),
+        ]
+        for token in tokens
+    ]
+    display_table(["Token ID", "Created at", "Scoped"], rows, json=json)
+
+
+@proxy_tokens_cli.command("allow", help="Allow a proxy token to authenticate to an environment.", no_args_is_help=True)
+@click.argument("token_id")
+@click.argument("environment_name")
+def proxy_tokens_allow(token_id: str, environment_name: str):
+    Workspace.from_context().proxy_tokens.allow(token_id, environment_name)
+    rich.print(f"[green]✓[/green] Allowed proxy token {token_id!r} to authenticate to environment {environment_name!r}")
+
+
+@proxy_tokens_cli.command("revoke", help="Revoke a proxy token's access to an environment.", no_args_is_help=True)
+@click.argument("token_id")
+@click.argument("environment_name")
+def proxy_tokens_revoke(token_id: str, environment_name: str):
+    Workspace.from_context().proxy_tokens.revoke(token_id, environment_name)
+    rich.print(f"[green]✓[/green] Revoked proxy token {token_id!r} access to environment {environment_name!r}")
+
+
+@proxy_tokens_cli.command("delete", help="Delete a proxy token from the current Workspace.", no_args_is_help=True)
+@click.argument("token_id")
+@yes_option
+def proxy_tokens_delete(token_id: str, yes: bool = False):
+    if not yes:
+        message = (
+            f"Are you sure you want to delete proxy token {token_id!r}? "
+            "Any web endpoints relying on it will no longer accept it."
+        )
+        confirm_or_suggest_yes(message)
+    Workspace.from_context().proxy_tokens.delete(token_id)
+    rich.print(f"[green]✓[/green] Deleted proxy token {token_id!r}")

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.1.dev14",
+        version: str = "1.5.1.dev15",
     ):
         """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.5.1.dev14",
+        version: str = "1.5.1.dev15",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.5.1.dev14 → modal-1.5.1.dev15}/modal/sandbox.py

@@ -16,6 +16,8 @@ from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import TYPE_CHECKING, Any, Literal, Union, overload
 
+from modal.secret import _split_env_dict_and_resolvable_secrets
+
 from ._output.pty import get_pty_info
 from .config import config, logger
 
@@ -843,6 +845,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         encrypted_ports: Sequence[int] = [],
         h2_ports: Sequence[int] = [],
         unencrypted_ports: Sequence[int] = [],
+        readiness_probe: Probe | None = None,
         include_oidc_identity_token: bool = False,
         verbose: bool = False,
         client: _Client | None = None,
@@ -851,11 +854,11 @@ class _Sandbox(_Object, type_prefix="sb"):
 
         Supported features include exec, encrypted tunnels, wait/poll/terminate,
         CPU and memory configuration, region placement, volumes, cloud bucket mounts
-        (with static credentials via `secret=...`), and filesystem snapshots.
+        (with static credentials via `secret=...` or `oidc_auth_role_arn`), OIDC
+        identity tokens, and filesystem snapshots.
 
         Features like tags, memory snapshots, network file systems, GPUs, custom
-        domains, OIDC identity tokens (including `oidc_auth_role_arn` on a
-        CloudBucketMount), and proxies are not supported.
+        domains, and proxies are not supported.
 
         V2 sandboxes created with this method are not currently returned by
         `Sandbox.list()` and cannot be looked up with `Sandbox.from_name()`.
@@ -878,20 +881,6 @@ class _Sandbox(_Object, type_prefix="sb"):
         cloud_bucket_mounts = [(k, v) for k, v in validated_volumes if isinstance(v, _CloudBucketMount)]
         validated_volumes = [(k, v) for k, v in validated_volumes if isinstance(v, _Volume)]
 
-        # The V2 backend does not yet propagate `oidc_identity_token` from server to worker - it is silently dropped
-        # TODO(akshay) add support for OIDC tokens
-        if include_oidc_identity_token:
-            raise InvalidError(
-                "Sandbox._experimental_create does not support include_oidc_identity_token=True. "
-                "Use Sandbox.create instead."
-            )
-        for path, cbm in cloud_bucket_mounts:
-            if cbm.oidc_auth_role_arn:
-                raise InvalidError(
-                    "Sandbox._experimental_create does not support CloudBucketMount with oidc_auth_role_arn "
-                    f"(at mount path {path!r}). Use static credentials via `secret=...`, or use Sandbox.create."
-                )
-
         secrets = secrets or []
         ephemeral_env: dict[str, str] = {}
         if env:
@@ -981,6 +970,7 @@ class _Sandbox(_Object, type_prefix="sb"):
                 inbound_cidr_allowlist=list(inbound_cidr_allowlist) if inbound_cidr_allowlist is not None else [],
                 volume_mounts=volume_mounts,
                 cloud_bucket_mounts=cloud_bucket_mounts_to_proto(cloud_bucket_mounts),
+                readiness_probe=(readiness_probe._to_proto() if readiness_probe else None),
             )
 
             create_req = api_pb2.SandboxCreateV2Request(
@@ -1857,10 +1847,11 @@ class _Sandbox(_Object, type_prefix="sb"):
         _validate_exec_args(args)
 
         secrets = list(secrets or [])
-        env_dict = {k: v for k, v in (env or {}).items() if v is not None}
+        env_dict, resolvable_secrets = _split_env_dict_and_resolvable_secrets(secrets)
+        env_dict |= {k: v for k, v in (env or {}).items() if v is not None}
 
         # Force explicit secret resolution so we can pass the secret IDs to the backend.
-        secret_coros = [secret.hydrate(client=self._client) for secret in secrets]
+        secret_coros = [secret.hydrate(client=self._client) for secret in resolvable_secrets]
         await TaskContext.gather(*secret_coros)
 
         task_id = await self._get_task_id(raise_if_task_complete=True)
@@ -1878,7 +1869,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             stderr=stderr,
             timeout=timeout,
             workdir=workdir,
-            secret_ids=[secret.object_id for secret in secrets],
+            secret_ids=[secret.object_id for secret in resolvable_secrets],
             env=env_dict,
             text=text,
             bufsize=bufsize,