modal 1.5.6.dev31__tar.gz → 1.6.1__tar.gz

{modal-1.5.6.dev31 → modal-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev31
+Version: 1.6.1
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0
@@ -21,9 +21,9 @@ Requires-Dist: certifi
 Requires-Dist: click~=8.1
 Requires-Dist: grpclib<0.4.10,>=0.4.7; python_version < "3.14"
 Requires-Dist: grpclib<0.4.10,>=0.4.9; python_version >= "3.14"
-Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
+Requires-Dist: protobuf!=4.24.0,<8.0,>=3.19
 Requires-Dist: rich>=12.0.0
-Requires-Dist: synchronicity~=0.12.5
+Requires-Dist: synchronicity~=0.12.6
 Requires-Dist: toml
 Requires-Dist: types-certifi
 Requires-Dist: types-toml

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_environments.py

@@ -22,7 +22,7 @@ from ._utils.time_utils import is_utc_month_aligned, parse_billing_cycle
 from .client import _Client
 from .config import config, logger
 from .exception import InvalidError, WorkspaceManagementError
-from .types import BillingReportItem, EnvironmentBillingSummary
+from .types import AppInfo, BillingReportItem, EnvironmentBillingSummary
 
 if TYPE_CHECKING:
     import modal
@@ -346,6 +346,7 @@ class _EnvironmentAppsManager:
                 self._environment.name,
                 self._environment.client,
                 description=item.description or None,
+                info=AppInfo._from_proto(item.metadata, item.app_id),
             )
             for item in response.apps
             if item.state not in stopped_app_states

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_functions.py

@@ -7,7 +7,7 @@ import time
 import typing
 import warnings
 from collections import OrderedDict
-from collections.abc import AsyncGenerator, AsyncIterator, Callable, Collection, Sequence
+from collections.abc import AsyncGenerator, Callable, Collection, Sequence
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from pathlib import PurePosixPath
@@ -1749,14 +1749,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         return list(self._experimental_flash_urls) if self._experimental_flash_urls else None
 
     async def _fetch_flash_auth_token(self, retry: Retry) -> str:
-        resp = await self.client.stub.FunctionGetFlashAuthToken(
+        resp = await self.client._stub.FunctionGetFlashAuthToken(
             api_pb2.FunctionGetFlashAuthTokenRequest(function_id=self.object_id), retry=retry
         )
         return resp.token
 
     async def _get_flash_auth_token(self) -> str:
         if self._flash_token_manager is None:
-            self._flash_token_manager = _AuthTokenManager(self.client.stub, fetch=self._fetch_flash_auth_token)
+            self._flash_token_manager = _AuthTokenManager(self.client._stub, fetch=self._fetch_flash_auth_token)
         return await self._flash_token_manager.get_token()
 
     def _apply_dynamic_config(
@@ -2405,7 +2405,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         return await self._invocation().poll_function(timeout=timeout, index=index)
 
     @live_method_gen
-    async def iter(self, *, start: int = 0, end: int | None = None) -> AsyncIterator[ReturnType]:
+    async def iter(self, *, start: int = 0, end: int | None = None) -> AsyncGenerator[ReturnType, None]:
         """Iterate in-order over the results of the function call.
 
         Optionally, specify a range [start, end) to iterate over.

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_object.py

@@ -4,10 +4,10 @@ import typing
 import uuid
 from collections.abc import Awaitable, Callable, Hashable, Sequence
 from functools import wraps
-from typing import ClassVar
+from typing import Any, AsyncContextManager, AsyncGenerator, AsyncIterator, ClassVar, ParamSpec, TypeVar
 
 from google.protobuf.message import Message
-from typing_extensions import Self
+from typing_extensions import Concatenate, Self
 
 from ._load_context import LoadContext
 from ._resolver import Resolver
@@ -38,18 +38,24 @@ def _get_environment_name(
         return config.get("environment") or ""
 
 
-def live_method(method):
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def live_method(method: Callable[Concatenate[Any, P], Awaitable[T]]) -> Callable[Concatenate[Any, P], Awaitable[T]]:
     @wraps(method)
-    async def wrapped(self, *args, **kwargs):
+    async def wrapped(self, *args: P.args, **kwargs: P.kwargs) -> T:
         await self.hydrate()
         return await method(self, *args, **kwargs)
 
     return wrapped
 
 
-def live_method_gen(method):
+def live_method_gen(
+    method: Callable[Concatenate[Any, P], AsyncGenerator[T, None]],
+) -> Callable[Concatenate[Any, P], AsyncIterator[T]]:
     @wraps(method)
-    async def wrapped(self, *args, **kwargs):
+    async def wrapped(self, *args: P.args, **kwargs: P.kwargs) -> AsyncIterator[T]:
         await self.hydrate()
         async with aclosing(method(self, *args, **kwargs)) as stream:
             async for item in stream:
@@ -58,14 +64,16 @@ def live_method_gen(method):
     return wrapped
 
 
-def live_method_contextmanager(method):
+def live_method_contextmanager(
+    method: Callable[Concatenate[Any, P], AsyncContextManager[T]],
+) -> Callable[Concatenate[Any, P], AsyncContextManager[T]]:
     # make sure a wrapped function returning an async context manager
     # will not require both an `await func.aio()` and `async with`
     # which would have been the case if it was wrapped in live_method
 
     @wraps(method)
     @contextlib.asynccontextmanager
-    async def wrapped(self, *args, **kwargs):
+    async def wrapped(self, *args: P.args, **kwargs: P.kwargs):
         await self.hydrate()
         async with method(self, *args, **kwargs) as ctx:
             yield ctx
@@ -75,7 +83,7 @@ def live_method_contextmanager(method):
 
 class _Object:
     _type_prefix: ClassVar[str | None] = None
-    _prefix_to_type: ClassVar[dict[str, type]] = {}
+    _prefix_to_type: ClassVar[dict[str, type["_Object"]]] = {}
 
     # For constructors
     _load: Callable[[Self, Resolver, LoadContext, str | None], Awaitable[None]] | None = None

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_output/status.py

@@ -13,9 +13,7 @@ from .manager import OutputManager
 
 
 def _get_annotation_for_web_url(url_info: api_pb2.WebUrlInfo) -> str:
-    if url_info.truncated:
-        suffix = " [grey70](label truncated)[/grey70]"
-    elif url_info.label_stolen:
+    if url_info.label_stolen:
         suffix = " [grey70](label stolen)[/grey70]"
     else:
         suffix = ""

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_partial_function.py

@@ -732,7 +732,7 @@ def _sessioned() -> Callable[
     [Callable[P, ReturnType] | _PartialFunction[P, ReturnType, ReturnType]],
     _PartialFunction[P, ReturnType, ReturnType],
 ]:
-    """Decorator that enables sessions on a Server.
+    """Decorator that enables sticky sessions on a Server.
 
     Every request must carry a session token obtained from a session start request; requests with the same token are
     routed to the same container until the session is idle for `idle_timeout` seconds or explicitly terminated. A

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_server.py

@@ -1,7 +1,10 @@
 # Copyright Modal Labs 2025
+import asyncio
 import inspect
 import json
+import time
 import typing
+import uuid
 from datetime import datetime, timedelta, timezone
 
 from typing_extensions import Self
@@ -113,7 +116,7 @@ class _Server:
 
     @property
     def sessions(self) -> "_ServerSessionsManager":
-        """Start and terminate sessions on a Server decorated with `@modal.sessioned()`."""
+        """Start and terminate sticky sessions on a Server decorated with `@modal.sessioned()`."""
         return _ServerSessionsManager(self)
 
     async def info(self, *, refresh: bool = False) -> ServerInfo:
@@ -160,7 +163,7 @@ class _Server:
         This interface is experimental and may change or be removed without warning.
         """
         service_function = self._get_service_function()
-        response = await service_function.client.stub.FlashContainerList(
+        response = await service_function.client._stub.FlashContainerList(
             api_pb2.FlashContainerListRequest(function_id=service_function.object_id)
         )
         return [
@@ -473,13 +476,12 @@ class _Server:
         request.until.FromDatetime(until)
         if container:
             request.container_id = container
-        stats = await self._get_service_function().client.stub.ServerGetTimeRangeStats(request)
+        stats = await self._get_service_function().client._stub.ServerGetTimeRangeStats(request)
         return ServerStats._from_proto(stats)
 
 
-@retry(n_attempts=5, base_delay=0.5, attempt_timeout=65, total_timeout=200)
 async def _post_session_control(url: str, headers: dict[str, str]) -> tuple[int, str, str]:
-    """POST to a session control endpoint, retrying connection errors and 5xx. Returns (status, reason, body)."""
+    """POST to a sticky session control endpoint, raising on 5xx."""
     async with ClientSessionRegistry.get_session().post(url, headers=headers) as resp:
         body = await resp.text()
         if resp.status >= 400:
@@ -489,6 +491,28 @@ async def _post_session_control(url: str, headers: dict[str, str]) -> tuple[int,
         return resp.status, resp.reason or "", body
 
 
+async def _post_session_start(base_url: str, fn: _Function, idle_timeout: int) -> tuple[int, str, str]:
+    idempotency_key = str(uuid.uuid4())
+    start_timestamp = str(time.time())
+
+    @retry(n_attempts=5, base_delay=0.5, attempt_timeout=None, total_timeout=1515)
+    async def attempt() -> tuple[int, str, str]:
+        headers = {
+            "Modal-Authorization": f"Bearer {await fn._get_flash_auth_token()}",
+            "x-idempotency-key": idempotency_key,
+            "x-modal-timestamp": start_timestamp,
+            "x-modal-server-session-idle-timeout": str(idle_timeout),
+        }
+        return await _post_session_control(f"{base_url}/_modal/sessions/start", headers)
+
+    return await attempt()
+
+
+@retry(n_attempts=3, base_delay=0.5, attempt_timeout=None, total_timeout=60)
+async def _post_session_terminate(base_url: str, headers: dict[str, str]) -> tuple[int, str, str]:
+    return await _post_session_control(f"{base_url}/_modal/sessions/terminate", headers)
+
+
 class _ServerSessionsManager:
     """mdmd:namespace"""
 
@@ -501,11 +525,15 @@ class _ServerSessionsManager:
             raise InvalidError("`sessions` requires `@modal.sessioned()` on the Server.")
 
     async def start(self, idle_timeout: int = 600) -> ServerSessionCredentials:
-        """Start a session and return its ID and token.
+        """Start a sticky session and return its ID and token.
+
+        Requests to the server URL that carry the returned token are routed to the same container until the
+        session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+        for as long as it holds a live session.
 
-        Requests to the server URL that carry the returned token are routed to the same container until the session
-        has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-        as it holds a live session.
+        If no container has room for the session, the call waits for additional capacity. It will block for
+        up to 25 minutes before giving up. To control the wait per call, use the HTTP API and apply your own retry
+        policy.
 
         Args:
             idle_timeout: Seconds without an in-flight request before the session ends.
@@ -531,13 +559,10 @@ class _ServerSessionsManager:
         self._validate()
         assert url is not None, "Server has no URL."
 
-        headers = {
-            "Modal-Authorization": f"Bearer {await fn._get_flash_auth_token()}",
-            "x-modal-server-session-idle-timeout": str(idle_timeout),
-        }
-
         try:
-            status, reason, body = await _post_session_control(f"{url}/_modal/sessions/start", headers)
+            status, reason, body = await _post_session_start(url, fn, idle_timeout)
+        except asyncio.TimeoutError:
+            raise asyncio.TimeoutError("Failed to start session: timed out") from None
         except ServiceError as exc:
             raise ExecutionError(f"Failed to start session: {exc}") from None
         if status >= 400:
@@ -550,7 +575,9 @@ class _ServerSessionsManager:
             raise ExecutionError("Failed to start session: unexpected response from server") from None
 
     async def terminate(self, token: str) -> None:
-        """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+        """Terminate a sticky session.
+
+        New requests to it will be rejected. The container continues serving other sessions.
 
         Args:
             token: The `token` of the `ServerSessionCredentials` to terminate.
@@ -574,7 +601,7 @@ class _ServerSessionsManager:
             "x-modal-server-session-token": token,
         }
         try:
-            status, reason, _body = await _post_session_control(f"{url}/_modal/sessions/terminate", headers)
+            status, reason, _body = await _post_session_terminate(url, headers)
         except ServiceError as exc:
             raise ExecutionError(f"Failed to terminate session: {exc}") from None
         if status == 404:

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_server.pyi

@@ -67,7 +67,7 @@ class _Server:
 
     @property
     def sessions(self) -> _ServerSessionsManager:
-        """Start and terminate sessions on a Server decorated with `@modal.sessioned()`."""
+        """Start and terminate sticky sessions on a Server decorated with `@modal.sessioned()`."""
         ...
 
     async def info(self, *, refresh: bool = False) -> modal.types.ServerInfo:
@@ -272,9 +272,14 @@ class _Server:
         ...
 
 async def _post_session_control(url: str, headers: dict[str, str]) -> tuple[int, str, str]:
-    """POST to a session control endpoint, retrying connection errors and 5xx. Returns (status, reason, body)."""
+    """POST to a sticky session control endpoint, raising on 5xx."""
     ...
 
+async def _post_session_start(
+    base_url: str, fn: modal._functions._Function, idle_timeout: int
+) -> tuple[int, str, str]: ...
+async def _post_session_terminate(base_url: str, headers: dict[str, str]) -> tuple[int, str, str]: ...
+
 class _ServerSessionsManager:
     """mdmd:namespace"""
     def __init__(self, server: _Server):
@@ -283,11 +288,15 @@ class _ServerSessionsManager:
 
     def _validate(self) -> None: ...
     async def start(self, idle_timeout: int = 600) -> modal.types.ServerSessionCredentials:
-        """Start a session and return its ID and token.
+        """Start a sticky session and return its ID and token.
+
+        Requests to the server URL that carry the returned token are routed to the same container until the
+        session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+        for as long as it holds a live session.
 
-        Requests to the server URL that carry the returned token are routed to the same container until the session
-        has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-        as it holds a live session.
+        If no container has room for the session, the call waits for additional capacity. It will block for
+        up to 25 minutes before giving up. To control the wait per call, use the HTTP API and apply your own retry
+        policy.
 
         Args:
             idle_timeout: Seconds without an in-flight request before the session ends.
@@ -308,7 +317,9 @@ class _ServerSessionsManager:
         ...
 
     async def terminate(self, token: str) -> None:
-        """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+        """Terminate a sticky session.
+
+        New requests to it will be rejected. The container continues serving other sessions.
 
         Args:
             token: The `token` of the `ServerSessionCredentials` to terminate.
@@ -334,11 +345,15 @@ class ServerSessionsManager:
 
     class __start_spec(typing_extensions.Protocol):
         def __call__(self, /, idle_timeout: int = 600) -> modal.types.ServerSessionCredentials:
-            """Start a session and return its ID and token.
+            """Start a sticky session and return its ID and token.
+
+            Requests to the server URL that carry the returned token are routed to the same container until the
+            session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+            for as long as it holds a live session.
 
-            Requests to the server URL that carry the returned token are routed to the same container until the session
-            has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-            as it holds a live session.
+            If no container has room for the session, the call waits for additional capacity. It will block for
+            up to 25 minutes before giving up. To control the wait per call, use the HTTP API and apply your own retry
+            policy.
 
             Args:
                 idle_timeout: Seconds without an in-flight request before the session ends.
@@ -359,11 +374,15 @@ class ServerSessionsManager:
             ...
 
         async def aio(self, /, idle_timeout: int = 600) -> modal.types.ServerSessionCredentials:
-            """Start a session and return its ID and token.
+            """Start a sticky session and return its ID and token.
 
-            Requests to the server URL that carry the returned token are routed to the same container until the session
-            has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down for as long
-            as it holds a live session.
+            Requests to the server URL that carry the returned token are routed to the same container until the
+            session has had no connections for `idle_timeout` seconds or is terminated. A container won't be scaled down
+            for as long as it holds a live session.
+
+            If no container has room for the session, the call waits for additional capacity. It will block for
+            up to 25 minutes before giving up. To control the wait per call, use the HTTP API and apply your own retry
+            policy.
 
             Args:
                 idle_timeout: Seconds without an in-flight request before the session ends.
@@ -387,7 +406,9 @@ class ServerSessionsManager:
 
     class __terminate_spec(typing_extensions.Protocol):
         def __call__(self, /, token: str) -> None:
-            """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+            """Terminate a sticky session.
+
+            New requests to it will be rejected. The container continues serving other sessions.
 
             Args:
                 token: The `token` of the `ServerSessionCredentials` to terminate.
@@ -404,7 +425,9 @@ class ServerSessionsManager:
             ...
 
         async def aio(self, /, token: str) -> None:
-            """Terminate a session. New requests to it will be rejected. Container will continue serving other sessions.
+            """Terminate a sticky session.
+
+            New requests to it will be rejected. The container continues serving other sessions.
 
             Args:
                 token: The `token` of the `ServerSessionCredentials` to terminate.

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_utils/grpc_utils.py

@@ -307,20 +307,19 @@ def create_channel_config(*, sustained_keepalive: bool = False) -> grpclib.confi
     HTTP/2 keepalive probes keep idle transports warm through stateful
     middleboxes and surface dead connections before retries reuse them.
 
-    `sustained_keepalive` clears the two grpclib defaults such that a probe
-    actually goes out every `_keepalive_time`, for as long as the connection is
-    open.
+    A probe goes out every `_keepalive_time` while the connection keeps sending
+    requests. `sustained_keepalive` also keeps probing a connection that only
+    awaits responses, for as long as it is open.
     """
-    ping_throttle_overrides: dict[str, Any] = {}
+    ping_throttle_overrides: dict[str, Any] = {
+        # Default 300s floor between probes, applied regardless of data
+        # despite the name, so it has to stay under `_keepalive_time`.
+        "_http2_min_sent_ping_interval_without_data": GRPC_KEEPALIVE_TIME_SECS / 2,
+    }
     if sustained_keepalive:
-        ping_throttle_overrides = {
-            # Default 2: probing stops after two probes with no request sent in
-            # between. Requests reset the count, acks don't. 0 = no cap.
-            "_http2_max_pings_without_data": 0,
-            # Default 300s floor between probes, applied regardless of data
-            # despite the name, so it has to stay under `_keepalive_time`.
-            "_http2_min_sent_ping_interval_without_data": GRPC_KEEPALIVE_TIME_SECS / 2,
-        }
+        # Default 2: probing stops after two probes with no request sent in
+        # between. Requests reset the count, acks don't. 0 = no cap.
+        ping_throttle_overrides["_http2_max_pings_without_data"] = 0
 
     return grpclib.config.Configuration(
         _keepalive_time=GRPC_KEEPALIVE_TIME_SECS,

{modal-1.5.6.dev31 → modal-1.6.1}/modal/_utils/task_command_router_client.py

@@ -226,6 +226,7 @@ async def fetch_command_router_access_v2(
     *,
     sandbox_id: str | None = None,
     task_id: str | None = None,
+    sandbox_token: str | None = None,
 ) -> api_pb2.SandboxGetCommandRouterAccessResponse:
     """Fetch direct command router access info from Modal server for a V2 sandbox."""
     if sandbox_id is not None:
@@ -236,10 +237,10 @@ async def fetch_command_router_access_v2(
         raise ValueError("Either sandbox_id or task_id must be provided")
     assert server_client._auth_token_manager
     auth_token = await server_client._auth_token_manager.get_token()
-    return await server_client._stub.SandboxGetCommandRouterAccess(
-        request,
-        metadata=[("x-modal-auth-token", auth_token)],
-    )
+    metadata = [("x-modal-auth-token", auth_token)]
+    if sandbox_token:
+        metadata.append(("x-modal-sandbox-token", sandbox_token))
+    return await server_client._stub.SandboxGetCommandRouterAccess(request, metadata=metadata)
 
 
 def _finalize_channel(loop, channel):
@@ -267,6 +268,7 @@ class TaskCommandRouterClient:
         jwt: str,
         *,
         sandbox_id: str | None = None,
+        sandbox_token: str | None = None,
     ) -> "TaskCommandRouterClient":
         """Build a connected client from a jwt and url."""
         o = urllib.parse.urlparse(url)
@@ -315,7 +317,17 @@ class TaskCommandRouterClient:
         loop = asyncio.get_running_loop()
         jwt_refresh_lock = asyncio.Lock()
 
-        client = cls(server_client, task_id, url, jwt, channel, loop, jwt_refresh_lock, sandbox_id=sandbox_id)
+        client = cls(
+            server_client,
+            task_id,
+            url,
+            jwt,
+            channel,
+            loop,
+            jwt_refresh_lock,
+            sandbox_id=sandbox_id,
+            sandbox_token=sandbox_token,
+        )
         # An unused client releases its connection too.
         client._arm_idle_release()
         return client
@@ -337,6 +349,8 @@ class TaskCommandRouterClient:
         sandbox_id: str,
         task_id: str,
         access: api_pb2.CommandRouterAccess | None = None,
+        *,
+        sandbox_token: str | None = None,
     ) -> "TaskCommandRouterClient":
         """Initialize a TaskCommandRouterClient for a V2 sandbox.
 
@@ -348,10 +362,12 @@ class TaskCommandRouterClient:
         if access is not None:
             url, jwt = access.url, access.jwt
         else:
-            resp = await fetch_command_router_access_v2(server_client, sandbox_id=sandbox_id)
+            resp = await fetch_command_router_access_v2(
+                server_client, sandbox_id=sandbox_id, sandbox_token=sandbox_token
+            )
             url, jwt = resp.url, resp.jwt
         logger.debug(f"Using command router access for sandbox {sandbox_id}")
-        return await cls._connect(server_client, task_id, url, jwt, sandbox_id=sandbox_id)
+        return await cls._connect(server_client, task_id, url, jwt, sandbox_id=sandbox_id, sandbox_token=sandbox_token)
 
     @classmethod
     async def init_v2_by_task_id(
@@ -375,6 +391,7 @@ class TaskCommandRouterClient:
         jwt_refresh_lock: asyncio.Lock,
         *,
         sandbox_id: str | None = None,
+        sandbox_token: str | None = None,
         stream_stdio_retry_delay_secs: float = 0.01,
         stream_stdio_retry_delay_factor: float = 2,
         stream_stdio_max_retries: int = 10,
@@ -388,6 +405,7 @@ class TaskCommandRouterClient:
         self._server_client = server_client
         self._task_id = task_id
         self._sandbox_id = sandbox_id
+        self._sandbox_token = sandbox_token
         self._server_url = server_url
         self._jwt = jwt
         self._channel = channel
@@ -902,7 +920,10 @@ class TaskCommandRouterClient:
             if self._is_v2_sandbox:
                 logger.debug(f"Refreshing JWT for V2 exec with task ID {self._task_id}")
                 v2_resp = await fetch_command_router_access_v2(
-                    self._server_client, sandbox_id=self._sandbox_id, task_id=self._task_id
+                    self._server_client,
+                    sandbox_id=self._sandbox_id,
+                    task_id=self._task_id,
+                    sandbox_token=self._sandbox_token,
                 )
                 logger.debug(f"Finished refreshing JWT for V2 exec with task ID {self._task_id}")
                 jwt, url = v2_resp.jwt, v2_resp.url