modAL 1.3.6.dev14__tar.gz → 1.4.1__tar.gz

{modal-1.3.6.dev14 → modal-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.3.6.dev14
+Version: 1.4.1
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0
@@ -23,7 +23,7 @@ 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: rich>=12.0.0
-Requires-Dist: synchronicity~=0.11.1
+Requires-Dist: synchronicity~=0.12.1
 Requires-Dist: toml
 Requires-Dist: typer>=0.9
 Requires-Dist: types-certifi

{modal-1.3.6.dev14 → modal-1.4.1}/modal/__init__.py

@@ -38,7 +38,7 @@ try:
     from .proxy import Proxy
     from .queue import Queue
     from .retries import Retries
-    from .sandbox import Sandbox
+    from .sandbox import Probe, Sandbox
     from .schedule import Cron, Period
     from .scheduler_placement import SchedulerPlacement
     from .secret import Secret
@@ -68,6 +68,7 @@ __all__ = [
     "Image",
     "NetworkFileSystem",
     "Period",
+    "Probe",
     "Proxy",
     "Queue",
     "Retries",

{modal-1.3.6.dev14 → modal-1.4.1}/modal/_functions.py

@@ -1562,7 +1562,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         input_queue: _SynchronizedQueue,
         order_outputs: bool,
         return_exceptions: bool,
-        wrap_returned_exceptions: bool,
     ) -> AsyncGenerator[Any, None]:
         """mdmd:hidden
 
@@ -1588,7 +1587,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     self.client,
                     order_outputs,
                     return_exceptions,
-                    wrap_returned_exceptions,
                     count_update_callback,
                 )
             ) as stream:
@@ -1602,7 +1600,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     self.client,
                     order_outputs,
                     return_exceptions,
-                    wrap_returned_exceptions,
                     count_update_callback,
                     api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC,
                 )

{modal-1.3.6.dev14 → modal-1.4.1}/modal/_output/pty.py

@@ -147,6 +147,11 @@ async def get_app_logs_loop(
             # doesn't support server-side search)
             if search_text and search_text not in log.data:
                 return
+            # Search results may lack trailing newlines; ensure each
+            # match is a complete line so the LineBufferedOutput buffer
+            # doesn't merge it with the next match.
+            if search_text and not log.data.endswith("\n"):
+                log.data += "\n"
             if pty_shell_finish_event:
                 await output_mgr.put_pty_content(log)
             else:

{modal-1.3.6.dev14 → modal-1.4.1}/modal/_utils/async_utils.py

@@ -349,19 +349,18 @@ def retry(
     direct_fn=None,
     *,
     n_attempts=3,
-    base_delay=0,
+    base_delay=0.0,
     delay_factor=2,
+    max_delay: Optional[float] = None,
     attempt_timeout: Optional[float] = 90,
-    attempt_timeout_factor=1,
+    total_timeout: Optional[float] = None,
 ):
     """Decorator that calls an async function multiple times, with a given timeout.
 
     If a `base_delay` is provided, the function is given an exponentially
     increasing delay on each run, up until the maximum number of attempts.
 
-    If `attempt_timeout_factor` is set to a value > 1, the per-attempt timeout
-    increases exponentially (starting from `attempt_timeout`, multiplied by
-    `attempt_timeout_factor` after each failed attempt).
+    If `max_delay` is set, the delay between attempts is capped at this value.
 
     Usage:
 
@@ -377,6 +376,7 @@ def retry(
         pass
     ```
     """
+    ATTEMPT_TIMEOUT_FLOOR = 2.0
 
     def decorator(fn):
         @functools.wraps(fn)
@@ -387,17 +387,35 @@ def retry(
                 local_n_attempts = n_attempts
 
             delay = base_delay
-            current_attempt_timeout = attempt_timeout
+            if total_timeout is not None:
+                total_deadline = time.time() + total_timeout
+            else:
+                total_deadline = None
+
             for i in range(local_n_attempts):
                 t0 = time.time()
+
+                timeouts = []
+                if attempt_timeout is not None:
+                    timeouts.append(attempt_timeout)
+                if total_deadline is not None:
+                    timeouts.append(max(total_deadline - time.time(), ATTEMPT_TIMEOUT_FLOOR))
+                timeout = min(timeouts) if timeouts else None
+
                 try:
-                    return await asyncio.wait_for(fn(*args, **kwargs), timeout=current_attempt_timeout)
+                    return await asyncio.wait_for(fn(*args, **kwargs), timeout=timeout)
                 except asyncio.CancelledError:
                     logger.debug(f"Function {fn} was cancelled")
                     raise
                 except Exception as e:
                     if i >= local_n_attempts - 1:
                         raise
+
+                    # We check if the timeout will be reached **after** the sleep, so we can raise an error early
+                    # without needing to actually sleep.
+                    if total_deadline is not None and time.time() + delay + ATTEMPT_TIMEOUT_FLOOR >= total_deadline:
+                        raise
+
                     logger.debug(
                         f"Failed invoking function {fn}: {e}"
                         f" (took {time.time() - t0}s, sleeping {delay}s"
@@ -405,8 +423,8 @@ def retry(
                     )
                 await asyncio.sleep(delay)
                 delay *= delay_factor
-                if current_attempt_timeout is not None:
-                    current_attempt_timeout *= attempt_timeout_factor
+                if max_delay is not None:
+                    delay = min(delay, max_delay)
 
         return f_wrapped
 

{modal-1.3.6.dev14 → modal-1.4.1}/modal/_utils/grpc_utils.py

@@ -90,8 +90,6 @@ RETRYABLE_GRPC_STATUS_CODES = [
 ]
 SERVER_RETRY_WARNING_TIME_INTERVAL = 30.0
 # Initial per-attempt timeout for TCP/TLS handshake in connect_channel.
-# Doubles each attempt (attempt_timeout_factor=2): 0.5 + 1 + 2 + 4 + 8 = 15.5s + ~1.5s inter-attempt delays.
-CONNECT_TIMEOUT = 0.5
 DEFAULT_MAX_RETRIES = 3
 
 
@@ -225,7 +223,8 @@ def create_channel(
     return channel
 
 
-@retry(n_attempts=5, base_delay=0.1, attempt_timeout=CONNECT_TIMEOUT, attempt_timeout_factor=2)
+# With 18 attempts, the max delays between calls is: 0.1 + 0.2 + 0.4 + 0.8 + 1.6 + 3.2 + 5*11 ~ 62
+@retry(n_attempts=18, base_delay=0.1, attempt_timeout=10.0, max_delay=5.0, total_timeout=63.0)
 async def connect_channel(channel: grpclib.client.Channel):
     """Connect to socket and raise exceptions when there is a connection issue."""
     await channel.__connect__()

{modal-1.3.6.dev14 → modal-1.4.1}/modal/_utils/sandbox_fs_utils.py

@@ -28,6 +28,7 @@ _EXEC_SANDBOX_UNAVAILABLE_ERROR_TYPES = (NotFoundError, ServiceError, Connection
 class ErrorPayload:
     error_kind: str
     message: str
+    detail: str = ""
 
 
 def _stderr_to_text(stderr: Union[str, bytes]) -> str:
@@ -51,11 +52,18 @@ def try_parse_error_payload(stderr: Union[str, bytes]) -> Optional[ErrorPayload]
         return None
     if not isinstance(message, str) or not message.strip():
         return None
-    return ErrorPayload(error_kind=error_kind, message=message)
+    detail = payload.get("detail", "")
+    if not isinstance(detail, str):
+        detail = ""
+    return ErrorPayload(error_kind=error_kind, message=message, detail=detail)
 
 
 def raise_read_file_error(returncode: int, stderr: Union[str, bytes], remote_path: str) -> NoReturn:
     if payload := try_parse_error_payload(stderr):
+        logger.debug(
+            f"sandbox-fs-tools read 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 == "IsDirectory":
@@ -106,6 +114,10 @@ def translate_exec_unexpected_error(operation: str, path: str, exc: Exception) -
 
 def raise_write_file_error(returncode: int, stderr: Union[str, bytes], remote_path: str) -> NoReturn:
     if payload := try_parse_error_payload(stderr):
+        logger.debug(
+            f"sandbox-fs-tools write error: path={remote_path}, "
+            f"error_kind={payload.error_kind}, message={payload.message}, detail={payload.detail}"
+        )
         if payload.error_kind == "NotDirectory" or payload.error_kind == "AlreadyExists":
             raise SandboxFilesystemNotADirectoryError(f"{payload.message}: {remote_path}")
         if payload.error_kind == "IsDirectory":

{modal-1.3.6.dev14 → modal-1.4.1}/modal/_utils/task_command_router_client.py

@@ -2,6 +2,7 @@
 import asyncio
 import base64
 import json
+import socket
 import ssl
 import time
 import urllib.parse
@@ -11,7 +12,6 @@ from typing import AsyncGenerator, Optional
 
 import grpclib.client
 import grpclib.config
-import grpclib.events
 from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
@@ -22,8 +22,21 @@ from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
 from .._grpc_client import grpc_error_converter
 from .._utils.grpc_utils import PermanentCloseableChannel
-from .async_utils import aclosing
-from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel
+from .async_utils import aclosing, retry
+from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
+
+
+@retry(n_attempts=34, base_delay=1, max_delay=10, attempt_timeout=10, total_timeout=310)
+async def _connect_channel(channel: grpclib.client.Channel):
+    """Connect to the command router channel.
+
+    Uses a longer retry budget than grpc_utils.connect_channel. In rare cases the sandbox
+    may take a long time to start on the worker after scheduling.
+
+    Retries with exponential backoff (1, 2, 4, 8, 10, 10, ...) capped at 10s per delay.
+    Total sleep between attempts: 1 + 2 + 4 + 8 + 10*29 = 305s (~5 min).
+    """
+    await channel.__connect__()
 
 
 def _b64url_decode(data: str) -> bytes:
@@ -169,7 +182,10 @@ class TaskCommandRouterClient:
             closed_error_message="Unable to perform operation on a detached sandbox",
         )
 
-        await connect_channel(channel)
+        try:
+            await _connect_channel(channel)
+        except socket.gaierror as exc:
+            raise ConnectionError(f"Could not resolve hostname '{host}': {exc}") from exc
         loop = asyncio.get_running_loop()
         jwt_refresh_lock = asyncio.Lock()
 

{modal-1.3.6.dev14 → modal-1.4.1}/modal/cli/app.py

@@ -164,7 +164,7 @@ def logs(
     Get recent logs based on an app ID:
 
     ```
-    modal app logs ap-123456 --tail 100
+    modal app logs ap-123456
     ```
 
     Get recent logs for a currently deployed App based on its name:
@@ -179,6 +179,12 @@ def logs(
     modal app logs my-app -f
     ```
 
+    Fetch the last 1000 entries:
+
+    ```
+    modal app logs my-app --tail 1000
+    ```
+
     Fetch logs from the last 2 hours:
 
     ```

{modal-1.3.6.dev14 → modal-1.4.1}/modal/cli/container.py

@@ -1,4 +1,5 @@
 # Copyright Modal Labs 2022
+import warnings
 from datetime import datetime, timezone
 from typing import Optional, Union
 
@@ -27,7 +28,11 @@ container_cli = typer.Typer(name="container", help="Manage and connect to runnin
 
 @container_cli.command("list")
 @synchronizer.create_blocking
-async def list_(env: Optional[str] = ENV_OPTION, json: bool = False, app_id: str = ""):
+async def list_(
+    app_id: str = typer.Option("", "--app-id", help="List containers running for a specific App."),
+    env: Optional[str] = ENV_OPTION,
+    json: bool = False,
+):
     """List all containers that are currently running."""
     env = ensure_env(env)
     client = await _Client.from_env()
@@ -113,6 +118,12 @@ async def logs(
     modal container logs ta-123456 --since 2026-03-01T05:00:00 --until 2026-03-01T08:00:00
     ```
 
+    Fetch the last 1000 entries:
+
+    ```
+    modal container logs ta-123456 --tail 1000
+    ```
+
     Fetch all container logs:
 
     ```
@@ -175,20 +186,40 @@ async def logs(
         task_info_resp = await client.stub.TaskGetInfo(api_pb2.TaskGetInfoRequest(task_id=task_id))
         app_id = task_info_resp.app_id
 
+        if not task_info_resp.info.started_at:
+            # Unlikely race or Modal backend issue, don't treat as a usage exception
+            return
+        container_started_dt = datetime.fromtimestamp(task_info_resp.info.started_at, timezone.utc)
+
         now = datetime.now(timezone.utc)
         if all_logs:
-            since_dt = datetime.fromtimestamp(task_info_resp.info.started_at, timezone.utc)
+            since_dt = container_started_dt
             if task_info_resp.info.finished_at:
                 until_dt = datetime.fromtimestamp(task_info_resp.info.finished_at, timezone.utc)
             else:
                 until_dt = now
         else:
-            since_dt = _parse_time_arg(since, default=now) if since else None
-            until_dt = _parse_time_arg(until, default=now) if until else None
+            since_dt = _parse_time_arg(since, default=container_started_dt)
+            if task_info_resp.info.finished_at:
+                default_until_dt = datetime.fromtimestamp(task_info_resp.info.finished_at, timezone.utc)
+            else:
+                default_until_dt = now
+            until_dt = _parse_time_arg(until, default=default_until_dt)
 
-        if since_dt is not None and until_dt is not None and since_dt >= until_dt:
+        if since is not None and until is not None and since_dt >= until_dt:
+            # User provided both --since and --until, but did so incorrectly
             raise UsageError("--since must be before --until.")
 
+        if since is not None and until is None and since_dt >= until_dt:
+            # User provided only --since and it is after the container finished
+            warnings.warn("--since time is after the Container finished, no logs to fetch.", UserWarning)
+            return
+
+        if until is not None and since is None and since_dt >= until_dt:
+            # User provided only --until and it is before the Container started
+            warnings.warn("--until time is before the Container started, no logs to fetch.", UserWarning)
+            return
+
         if since_dt is not None:
             effective_until = until_dt or now
             if effective_until - since_dt > _MAX_FETCH_RANGE:

{modal-1.3.6.dev14 → modal-1.4.1}/modal/cli/import_refs.py

@@ -127,6 +127,7 @@ class AutoRunPriority:
 
 def list_cli_commands(
     module_members: dict[str, typing.Any],
+    include_service_functions: bool = False,
 ) -> list[CLICommand]:
     """
     Extracts all runnables found either directly in the input module, or in any of the Apps listed in that module
@@ -149,8 +150,8 @@ def list_cli_commands(
             all_runnables[local_entrypoint].append(f"{app_name}.{name}")
             priorities[local_entrypoint] = AutoRunPriority.APP_LOCAL_ENTRYPOINT
         for name, function in app.registered_functions.items():
-            if function.info.is_service_class():
-                continue  # Skip class and server service functions since they don't have associated cli commands
+            if function.info.is_service_class() and not include_service_functions:
+                continue  # Skip class and server service functions for all commands except `modal shell`.
             all_runnables[function].append(f"{app_name}.{name}")
             priorities[function] = AutoRunPriority.APP_FUNCTION
         for cls_name, cls in app.registered_classes.items():
@@ -322,7 +323,12 @@ def _get_runnable_app(runnable: Runnable) -> App:
 
 
 def import_and_filter(
-    import_ref: ImportRef, *, base_cmd: str, accept_local_entrypoint=True, accept_webhook=False
+    import_ref: ImportRef,
+    *,
+    base_cmd: str,
+    accept_local_entrypoint=True,
+    accept_webhook=False,
+    accept_service_functions=False,
 ) -> tuple[Optional[Runnable], list[CLICommand]]:
     """Takes a function ref string and returns a single determined "runnable" to use, and a list of all available
     runnables.
@@ -339,7 +345,10 @@ def import_and_filter(
     """
     # all commands:
     module = import_file_or_module(import_ref, base_cmd)
-    cli_commands = list_cli_commands(dict(inspect.getmembers(module)))
+    cli_commands = list_cli_commands(
+        dict(inspect.getmembers(module)),
+        include_service_functions=accept_service_functions,
+    )
 
     # all commands that satisfy local entrypoint/accept webhook limitations AND object path prefix
 

{modal-1.3.6.dev14 → modal-1.4.1}/modal/cli/run.py

@@ -7,7 +7,7 @@ import sys
 import time
 import typing
 from dataclasses import dataclass
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, get_args
 
 import click
 import typer
@@ -504,7 +504,9 @@ def deploy(
         False, "-m", help="Interpret argument as a Python module path instead of a file/script path"
     ),
     timestamps: bool = typer.Option(False, "--timestamps", help="Show timestamps for each log line."),
-    strategy: DEPLOYMENT_STRATEGY_TYPE = typer.Option("rolling", help="Deployment strategy"),
+    strategy: str = typer.Option(
+        "rolling", help="Deployment strategy", click_type=click.Choice(get_args(DEPLOYMENT_STRATEGY_TYPE))
+    ),
 ):
     """Deploy a Modal application.
 

{modal-1.3.6.dev14 → modal-1.4.1}/modal/cli/shell.py

@@ -142,7 +142,11 @@ def _start_shell_in_running_container(ref: str, cmd: str, pty: bool) -> None:
 def _function_spec_from_ref(ref: str, use_module_mode: bool) -> _FunctionSpec:
     import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
     runnable, all_usable_commands = import_and_filter(
-        import_ref, base_cmd="modal shell", accept_local_entrypoint=False, accept_webhook=True
+        import_ref,
+        base_cmd="modal shell",
+        accept_local_entrypoint=False,
+        accept_webhook=True,
+        accept_service_functions=True,
     )
     if not runnable:
         help_header = (

{modal-1.3.6.dev14 → modal-1.4.1}/modal/client.py

@@ -22,7 +22,7 @@ from ._utils import async_utils
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.auth_token_manager import _AuthTokenManager
 from ._utils.grpc_utils import ConnectionManager
-from .config import _check_config, _is_remote, config, logger
+from .config import _agent_environment, _check_config, _is_remote, config, logger
 from .exception import AuthError, ClientClosed
 
 HEARTBEAT_INTERVAL: float = config.get("heartbeat_interval")
@@ -56,6 +56,8 @@ def _get_metadata(client_type: int, credentials: Optional[tuple[str, str]], vers
                 "x-modal-token-secret": token_secret,
             }
         )
+    if agent_env := _agent_environment():
+        metadata["x-modal-agent-harness"] = urllib.parse.quote(agent_env)
     return metadata
 
 

{modal-1.3.6.dev14 → modal-1.4.1}/modal/client.pyi

@@ -31,11 +31,7 @@ class _Client:
     client_type: int
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.6.dev14",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.4.1"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -167,11 +163,7 @@ class Client:
     client_type: int
 
     def __init__(
-        self,
-        server_url: str,
-        client_type: int,
-        credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.3.6.dev14",
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "1.4.1"
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.3.6.dev14 → modal-1.4.1}/modal/config.py

@@ -121,6 +121,36 @@ def _is_remote() -> bool:
     return os.environ.get("MODAL_IS_REMOTE") == "1"
 
 
+def _agent_environment() -> Optional[str]:
+    """Detect if the current process is running inside an AI agent harness.
+
+    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.
+    """
+    # 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"),
+        ("GEMINI_CLI", "gemini-cli"),
+        ("CURSOR_AGENT", "cursor"),
+        ("CLINE_ACTIVE", "cline"),
+        ("AUGMENT_AGENT", "augment"),
+        ("OPENCODE_CLIENT", "opencode"),
+        ("GOOSE_TERMINAL", "goose"),
+        ("TRAE_AI_SHELL_ID", "trae"),
+    ]
+    for env_var, agent_name in _TOOL_SPECIFIC_ENV_VARS:
+        if os.environ.get(env_var):
+            return agent_name
+
+    return None
+
+
 def _read_user_config():
     config_data = {}
     if not _is_remote() and os.path.exists(user_config_path):

{modal-1.3.6.dev14 → modal-1.4.1}/modal/dict.py

@@ -298,7 +298,8 @@ class _Dict(_Object, type_prefix="di"):
         )
 
     @classproperty
-    def objects(cls) -> _DictManager:
+    @classmethod
+    def objects(cls) -> type[_DictManager]:
         return _DictManager
 
     @property

{modal-1.3.6.dev14 → modal-1.4.1}/modal/dict.pyi

@@ -412,7 +412,8 @@ class _Dict(modal._object._Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> _DictManager: ...
+    @classmethod
+    def objects(cls) -> type[_DictManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
@@ -653,7 +654,8 @@ class Dict(modal.object.Object):
         ...
 
     @synchronicity.classproperty
-    def objects(cls) -> DictManager: ...
+    @classmethod
+    def objects(cls) -> type[DictManager]: ...
     @property
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...