modal 1.6.1.dev1__tar.gz → 1.6.2.dev0__tar.gz

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.6.1.dev1
+Version: 1.6.2.dev0
 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.6.1.dev1 → modal-1.6.2.dev0}/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.6.1.dev1 → modal-1.6.2.dev0}/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.6.1.dev1 → modal-1.6.2.dev0}/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
@@ -477,9 +480,8 @@ class _Server:
         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 sticky 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"""
 
@@ -507,6 +531,10 @@ class _ServerSessionsManager:
         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:
@@ -576,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.6.1.dev1 → modal-1.6.2.dev0}/modal/_server.pyi

@@ -272,9 +272,14 @@ class _Server:
         ...
 
 async def _post_session_control(url: str, headers: dict[str, str]) -> tuple[int, str, str]:
-    """POST to a sticky 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):
@@ -289,6 +294,10 @@ class _ServerSessionsManager:
         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.
 
@@ -342,6 +351,10 @@ class ServerSessionsManager:
             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.
 
@@ -367,6 +380,10 @@ class ServerSessionsManager:
             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.
 

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/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

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/modal/cli/function.py

@@ -112,6 +112,7 @@ def _time_range_stats_json(response: api_pb2.FunctionGetTimeRangeStatsResponse)
         "input_percentile_stats": _distribution_map_json(
             cast(dict[str, api_pb2.StatsPercentileDistribution], response.input_percentile_stats)
         ),
+        "container_total_count": response.container_total_count,
         "container_started_count": response.container_started_count,
         "container_error_count": response.container_error_count,
         "container_creating_at_end_count": response.container_creating_at_end_count,
@@ -794,9 +795,10 @@ async def stats(
 
     output.print("")
     container_count = resp.container_started_count + resp.container_error_count
+    total_containers = resp.container_total_count
     container_heading = Text("Containers", style=stats_style(STATS_SECTION_STYLE, use_color))
     container_heading.append(" " * (46 - len("Containers")))
-    container_heading.append(f"{container_count:,} total (")
+    container_heading.append(f"{total_containers:,} Total (")
     container_heading.append(
         f"{resp.container_creating_at_end_count:,} creating",
         style=progress_style(resp.container_creating_at_end_count, use_color),
@@ -806,12 +808,12 @@ async def stats(
 
     container_counts = Text("  ")
     container_counts.append(
-        _count_with_percentage(resp.container_started_count, container_count, "started"),
+        f"{resp.container_started_count:,} started",
         style=success_style(resp.container_started_count, container_count, use_color),
     )
     container_counts.append(" · ")
     container_counts.append(
-        _count_with_percentage(resp.container_error_count, container_count, "errored"),
+        f"{resp.container_error_count:,} errored",
         style=problem_style(resp.container_error_count, container_count, use_color),
     )
     output.print(container_counts)

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/modal/cli/server.py

@@ -33,7 +33,6 @@ from ._stats import (
     STATS_METADATA_STYLE,
     STATS_PROBLEM_STYLE,
     STATS_SECTION_STYLE,
-    _count_with_percentage,
     _distribution_map_json,
     _metric_rows,
     _percentile_table,
@@ -560,6 +559,7 @@ def _stats_json(
         "request_rate_per_second": history.request_rate_per_second,
         "container_started_count": history.container_started_count,
         "container_error_count": history.container_error_count,
+        "container_total_count": history.container_total_count,
         "container_creating_at_end_count": history.container_creating_at_end_count,
         "request_percentile_stats": _distribution_map_json(
             cast(dict[str, api_pb2.StatsPercentileDistribution], history.request_percentile_stats)
@@ -754,9 +754,10 @@ async def _run_server_stats(
 
     output.print("")
     container_count = history.container_started_count + history.container_error_count
+    container_total_count = history.container_total_count
     container_heading = Text("Containers", style=stats_style(STATS_SECTION_STYLE, use_color))
     container_heading.append(" " * (46 - len("Containers")))
-    container_heading.append(f"{container_count:,} total (")
+    container_heading.append(f"{container_total_count:,} Total (")
     container_heading.append(
         f"{history.container_creating_at_end_count:,} creating",
         style=progress_style(history.container_creating_at_end_count, use_color),
@@ -766,12 +767,12 @@ async def _run_server_stats(
 
     container_counts = Text("  ")
     container_counts.append(
-        _count_with_percentage(history.container_started_count, container_count, "started"),
+        f"{history.container_started_count:,} started",
         style=success_style(history.container_started_count, container_count, use_color),
     )
     container_counts.append(" · ")
     container_counts.append(
-        _count_with_percentage(history.container_error_count, container_count, "errored"),
+        f"{history.container_error_count:,} errored",
         style=problem_style(history.container_error_count, container_count, use_color),
     )
     output.print(container_counts)

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/modal/client.pyi

@@ -80,7 +80,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.6.1.dev1",
+        version: str = "1.6.2.dev0",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -290,7 +290,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.6.1.dev1",
+        version: str = "1.6.2.dev0",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/modal/config.py

@@ -134,13 +134,9 @@ def _agent_environment() -> str | None:
 
     Returns the agent name if detected, or None otherwise.
 
-    Checks the emerging `AGENT` standard variable first, then falls back to
-    tool-specific environment variables used by known agent harnesses.
+    Checks tool-specific environment variables used by known agent harnesses
+    first, then falls back to the emerging `AGENT` and `AI_AGENT` standards.
     """
-    # Emerging standard: AGENT=<name>
-    if agent := os.environ.get("AGENT"):
-        return agent
-
     # Tool-specific environment variables
     _TOOL_SPECIFIC_ENV_VARS: list[tuple[str, str]] = [
         ("CLAUDECODE", "claude-code"),
@@ -152,11 +148,23 @@ def _agent_environment() -> str | None:
         ("OPENCODE_CLIENT", "opencode"),
         ("GOOSE_TERMINAL", "goose"),  # honk
         ("TRAE_AI_SHELL_ID", "trae"),
+        ("PI_CODING_AGENT", "pi"),
+        ("COPILOT_AGENT_SESSION_ID", "copilot"),
+        ("ANTIGRAVITY_AGENT", "antigravity"),
+        ("JUNIE_SHIM_PATH", "junie"),
     ]
     for env_var, agent_name in _TOOL_SPECIFIC_ENV_VARS:
         if os.environ.get(env_var):
             return agent_name
 
+    # Emerging standards, checked last because neither value is normalized.
+    # `AGENT` may be a bare `1` rather than a name (opencode), and `AI_AGENT`
+    # may embed a version or suffix (e.g. `claude-code_2-1-268_agent`).
+    if agent := os.environ.get("AGENT"):
+        return agent
+    if agent := os.environ.get("AI_AGENT"):
+        return agent
+
     return None
 
 

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/modal/functions.pyi

@@ -613,7 +613,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.
 
@@ -638,7 +638,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -688,7 +688,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.
 
@@ -721,7 +721,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -729,7 +729,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_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.
 
@@ -762,7 +762,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     @property
     def _raw_f_(self) -> collections.abc.Callable[..., typing.Any]: ...

{modal-1.6.1.dev1 → modal-1.6.2.dev0}/modal/object.pyi

@@ -45,8 +45,6 @@ class Object:
     def _is_hydrated(self) -> bool: ...
     @_is_hydrated.setter
     def _is_hydrated(self, value: bool): ...
-    @classmethod
-    def __init_subclass__(cls, type_prefix: typing.Optional[str] = None): ...
     def _init(
         self,
         rep: str,