modal 1.4.4.dev15__tar.gz → 1.4.4.dev16__tar.gz

{modal-1.4.4.dev15 → modal-1.4.4.dev16}/PKG-INFO

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

{modal-1.4.4.dev15 → modal-1.4.4.dev16}/modal/_container_entrypoint.py

@@ -14,7 +14,6 @@ if telemetry_socket:
     from ._runtime.telemetry import instrument_imports
 
     instrument_imports(telemetry_socket)
-
 import asyncio
 import queue
 import signal
@@ -41,10 +40,11 @@ from ._runtime.container_io_manager import (
     ContainerIOManager,
     IOContext,
 )
-from ._runtime.task_lifecycle_manager import UserException
+from ._runtime.task_lifecycle_manager import TaskLifecycleManager, UserException
 
 if TYPE_CHECKING:
     import modal._runtime.container_io_manager
+    import modal._runtime.task_lifecycle_manager
     import modal._runtime.user_code_imports
 
 
@@ -287,12 +287,146 @@ def get_serialized_user_class_and_function(
     return ser_usr_cls, ser_fun
 
 
-def main(container_args: api_pb2.ContainerArguments, client: Client):
-    # This is a bit weird but we need both the blocking and async versions of ContainerIOManager.
-    # At some point, we should fix that by having built-in support for running "user code"
-    container_io_manager = ContainerIOManager(container_args, client)
+def get_server_service(
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+) -> Service:
+    ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
+    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
+    service_function_hydration_data = [
+        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
+    ][0]
+    service = import_server_service(
+        function_def,
+        service_function_hydration_data,
+        client,
+        ser_usr_cls,
+    )
+    return service
+
+
+def get_class_service(
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+) -> Service:
+    ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
+    if container_args.serialized_params:
+        param_args, param_kwargs = deserialize_params(container_args.serialized_params, function_def, _client)
+    else:
+        param_args = ()
+        param_kwargs = {}
+    # this is a bit ugly - match the function and class based on function name to get metadata
+    # This metadata is required in order to hydrate the class in case it's not globally
+    # decorated (or serialized)
+    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
+    service_function_hydration_data = [
+        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
+    ][0]
+    class_id = container_args.app_layout.class_ids[function_def.function_name.removesuffix(".*")]
+
+    service = import_class_service(
+        function_def,
+        service_function_hydration_data,
+        class_id,
+        client,
+        ser_usr_cls,
+        param_args,
+        param_kwargs,
+    )
+    return service
+
+
+def get_function_service(function_def: api_pb2.Function, _client: _Client) -> Service:
+    ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
+    assert ser_usr_cls is None
+    service = import_single_function_service(
+        function_def,
+        ser_fun,
+    )
+    return service
+
+
+def hydrate_function(
+    container_args: api_pb2.ContainerArguments,
+    task_lifecycle_manager: TaskLifecycleManager,
+    function_def: api_pb2.Function,
+    _client: _Client,
+    client: Client,
+) -> Service:
     active_app: _App
     service: Service
+    with task_lifecycle_manager.handle_task_lifecycle_exception():
+        with execution_context._import_context():
+            if function_def.is_server:
+                service = get_server_service(container_args, function_def, _client, client)
+            elif function_def.is_class:
+                service = get_class_service(container_args, function_def, _client, client)
+            else:
+                service = get_function_service(function_def, _client)
+
+        active_app = service.app
+
+    # Get ids and metadata for objects (primarily functions and classes) on the app
+    container_app: RunningApp = running_app_from_layout(container_args.app_id, container_args.app_layout)
+
+    # Initialize objects on the app.
+    # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
+    app: App = cast(App, synchronizer._translate_out(active_app))
+    app._init_container(client, container_app)
+
+    # Hydrate all function dependencies.
+    # TODO(erikbern): we an remove this once we
+    # 1. Enable lazy hydration for all objects
+    # 2. Fully deprecate .new() objects
+    if service.service_deps is not None:  # this is not set for serialized or non-global scope functions
+        dep_object_ids: list[str] = [dep.object_id for dep in function_def.object_dependencies]
+        if len(service.service_deps) != len(dep_object_ids):
+            raise ExecutionError(
+                f"Function has {len(service.service_deps)} dependencies"
+                f" but container got {len(dep_object_ids)} object ids.\n"
+                f"Code deps: {service.service_deps}\n"
+                f"Object ids: {dep_object_ids}\n"
+                "\n"
+                "This can happen if you are defining Modal objects under a conditional statement "
+                "that evaluates differently in the local and remote environments."
+            )
+        for object_id, obj in zip(dep_object_ids, service.service_deps):
+            metadata: Message | None = container_app.object_handle_metadata[object_id]
+            obj._hydrate(object_id, _client, metadata)
+
+    return service
+
+
+def run_server(container_args: api_pb2.ContainerArguments, client: Client):
+    function_def = container_args.function_def
+    _client: _Client = cast(_Client, synchronizer._translate_in(client))  # TODO(erikbern): ugly
+    task_lifecycle_manager = TaskLifecycleManager(
+        container_args.task_id,
+        container_args.function_id,
+        container_args.function_def,
+        container_args.checkpoint_id or None,
+        client,
+    )
+
+    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client, client)
+    # Initialize clustered functions.
+    if function_def._experimental_group_size > 0:
+        initialize_clustered_function(
+            client,
+            container_args.task_id,
+            function_def._experimental_group_size,
+        )
+
+    with UserCodeEventLoop() as event_loop:
+        with service.lifecycle_context(
+            event_loop,
+            task_lifecycle_manager=task_lifecycle_manager,
+        ):
+            call_server(event_loop)
+
+
+def run_function(container_args: api_pb2.ContainerArguments, client: Client):
+    # This is a bit weird but we need both the blocking and async versions of ContainerIOManager.
+    # At some point, we should fix that by having built-in support for running "user code"
+    container_io_manager: Any = ContainerIOManager(container_args, client)
     function_def = container_args.function_def
     # The worker sets this flag to "1" for snapshot and restore tasks. Otherwise, this flag is unset,
     # in which case snapshots should be disabled.
@@ -306,92 +440,17 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
     container_io_manager.hello()
 
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
-        # If this is a serialized function, fetch the definition from the server
-        ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
-
         # Initialize the function, importing user code.
-        with container_io_manager.get_task_lifecycle_manager().handle_task_lifecycle_exception():
-            if container_args.serialized_params:
-                param_args, param_kwargs = deserialize_params(container_args.serialized_params, function_def, _client)
-            else:
-                param_args = ()
-                param_kwargs = {}
-
-            with execution_context._import_context():
-                if function_def.is_server:
-                    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
-                    service_function_hydration_data = [
-                        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
-                    ][0]
-                    service = import_server_service(
-                        function_def,
-                        service_function_hydration_data,
-                        client,
-                        ser_usr_cls,
-                    )
-                elif function_def.is_class:
-                    # this is a bit ugly - match the function and class based on function name to get metadata
-                    # This metadata is required in order to hydrate the class in case it's not globally
-                    # decorated (or serialized)
-                    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
-                    service_function_hydration_data = [
-                        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
-                    ][0]
-                    class_id = container_args.app_layout.class_ids[function_def.function_name.removesuffix(".*")]
-
-                    service = import_class_service(
-                        function_def,
-                        service_function_hydration_data,
-                        class_id,
-                        client,
-                        ser_usr_cls,
-                        param_args,
-                        param_kwargs,
-                    )
-                else:
-                    assert ser_usr_cls is None
-                    service = import_single_function_service(
-                        function_def,
-                        ser_fun,
-                    )
-
-            active_app = service.app
-
-            if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
-                # Concurrency and batching doesn't apply for `modal shell`.
-                batch_max_size = 0
-                batch_wait_ms = 0
-            else:
-                batch_max_size = function_def.batch_max_size or 0
-                batch_wait_ms = function_def.batch_linger_ms or 0
-
-        # Get ids and metadata for objects (primarily functions and classes) on the app
-        container_app: RunningApp = running_app_from_layout(container_args.app_id, container_args.app_layout)
-
-        # Initialize objects on the app.
-        # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-        app: App = cast(App, synchronizer._translate_out(active_app))
-        app._init_container(client, container_app)
-
-        # Hydrate all function dependencies.
-        # TODO(erikbern): we an remove this once we
-        # 1. Enable lazy hydration for all objects
-        # 2. Fully deprecate .new() objects
-        if service.service_deps is not None:  # this is not set for serialized or non-global scope functions
-            dep_object_ids: list[str] = [dep.object_id for dep in function_def.object_dependencies]
-            if len(service.service_deps) != len(dep_object_ids):
-                raise ExecutionError(
-                    f"Function has {len(service.service_deps)} dependencies"
-                    f" but container got {len(dep_object_ids)} object ids.\n"
-                    f"Code deps: {service.service_deps}\n"
-                    f"Object ids: {dep_object_ids}\n"
-                    "\n"
-                    "This can happen if you are defining Modal objects under a conditional statement "
-                    "that evaluates differently in the local and remote environments."
-                )
-            for object_id, obj in zip(dep_object_ids, service.service_deps):
-                metadata: Message | None = container_app.object_handle_metadata[object_id]
-                obj._hydrate(object_id, _client, metadata)
+        service: Service = hydrate_function(
+            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client, client
+        )
+        if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
+            # Concurrency and batching doesn't apply for `modal shell`.
+            batch_max_size = 0
+            batch_wait_ms = 0
+        else:
+            batch_max_size = function_def.batch_max_size or 0
+            batch_wait_ms = function_def.batch_linger_ms or 0
 
         # Initialize clustered functions.
         if function_def._experimental_group_size > 0:
@@ -407,10 +466,14 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
         ) as finalized_functions:
             # This context managers handles pre/post snapshot lifecycle of the user code,
             # finalized functions, ASGI/WSGI lifespan, and volume commit.
-            if function_def.is_server:
-                call_server(event_loop)
-            else:
-                call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
+            call_function(event_loop, container_io_manager, finalized_functions, batch_max_size, batch_wait_ms)
+
+
+def main(container_args: api_pb2.ContainerArguments, client: Client):
+    if container_args.function_def.is_server:
+        run_server(container_args, client)
+    else:
+        run_function(container_args, client)
 
 
 if __name__ == "__main__":

{modal-1.4.4.dev15 → modal-1.4.4.dev16}/modal/cli/entry_point.py

@@ -25,6 +25,7 @@ from .network_file_system import nfs_cli
 from .profile import profile_cli
 from .queues import queue_cli
 from .secret import secret_cli
+from .skills import skills_cli
 from .token import _new_token, token_cli
 from .volume import volume_cli
 
@@ -117,6 +118,7 @@ entrypoint_cli.add_command(bootstrap, panel="Onboarding")
 entrypoint_cli.add_command(config_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(token_cli, panel="Configuration")
 
 entrypoint_cli.add_command(billing_cli, panel="Observability")

modal-1.4.4.dev16/modal/cli/skills.py

@@ -0,0 +1,310 @@
+# Copyright Modal Labs 2026
+
+import asyncio
+import re
+import shutil
+import tempfile
+from importlib import resources
+from pathlib import Path
+from urllib.parse import urlparse
+
+import click
+
+from modal.cli.utils import confirm_or_suggest_yes, yes_option
+from modal.output import OutputManager
+from modal_version import __version__
+
+from ._help import ModalGroup
+from .logo import GREEN, print_logo
+
+skills_cli = ModalGroup(name="skills", help="Install and update Modal's agent skills.")
+
+_SKILL_RESOURCE = "skills/modal/SKILL.md"
+_SKILL_NAME = "modal"
+_LLMS_TXT_URL = "https://modal.com/llms.txt"
+_DOCS_DOWNLOAD_TIMEOUT = 5.0
+_DOCS_DOWNLOAD_CONCURRENCY = 20
+# The slug allows `/` so nested doc paths (e.g. guide/functions/dynamic-config.md) are
+# matched; `_doc_resource_path` guards against `..`/absolute-path traversal.
+_DOC_URL_RE = re.compile(r"https://modal\.com/docs/(examples|guide)/[A-Za-z0-9._~%+/-]+\.md")
+
+
+def _target_dir(*, claude: bool, global_install: bool) -> Path:
+    base = Path.home() if global_install else Path.cwd()
+    agent_dir = ".claude" if claude else ".agents"
+    return base / agent_dir / "skills" / _SKILL_NAME
+
+
+def _skill_resource():
+    return resources.files("modal").joinpath(_SKILL_RESOURCE)
+
+
+def _skill_content_for_install() -> str:
+    content = _skill_resource().read_text()
+    lines = content.splitlines(keepends=True)
+
+    closing_idx = next(idx for idx, line in enumerate(lines[1:], start=1) if line.strip() == "---")
+
+    # Record the SDK version under the frontmatter `metadata` map, where the Agent
+    # Skills spec expects non-standard fields (rather than as a top-level key).
+    version_line = f'  version: "{__version__}"\n'
+    metadata_idx = next((idx for idx in range(1, closing_idx) if lines[idx].rstrip() == "metadata:"), None)
+    if metadata_idx is None:
+        lines.insert(closing_idx, "metadata:\n")
+        lines.insert(closing_idx + 1, version_line)
+        return "".join(lines)
+
+    for idx in range(metadata_idx + 1, closing_idx):
+        if lines[idx].strip() and not lines[idx][:1].isspace():
+            break  # reached the next top-level key; the metadata map has no version
+        if lines[idx].strip().startswith("version:"):
+            lines[idx] = version_line
+            return "".join(lines)
+    lines.insert(metadata_idx + 1, version_line)
+    return "".join(lines)
+
+
+def _target_has_modal_skill(target_dir: Path) -> bool:
+    try:
+        lines = (target_dir / "SKILL.md").read_text().splitlines()
+    except OSError:
+        return False
+    if not lines or lines[0].strip() != "---":
+        return False
+
+    for line in lines[1:]:
+        if line.strip() == "---":
+            return False
+        if line.strip() == f"name: {_SKILL_NAME}":
+            return True
+    return False
+
+
+def _extract_doc_urls(llms_txt: str) -> list[str]:
+    urls = []
+    seen = set()
+    for match in _DOC_URL_RE.finditer(llms_txt):
+        url = match.group(0)
+        if url not in seen:
+            seen.add(url)
+            urls.append(url)
+    return urls
+
+
+def _doc_resource_path(target_dir: Path, url: str) -> Path:
+    path = urlparse(url).path
+    examples_prefix = "/docs/examples/"
+    guide_prefix = "/docs/guide/"
+    if path.startswith(examples_prefix) and path.endswith(".md"):
+        rel_path = Path("examples") / path[len(examples_prefix) :]
+    elif path.startswith(guide_prefix) and path.endswith(".md"):
+        rel_path = Path("guide") / path[len(guide_prefix) :]
+    else:
+        raise ValueError(f"Unexpected Modal documentation URL: {url}")
+
+    if rel_path.is_absolute() or ".." in rel_path.parts:
+        raise ValueError(f"Unexpected Modal documentation URL: {url}")
+    return target_dir / "references" / rel_path
+
+
+def _llms_section_body(llms_txt: str, heading: str) -> str | None:
+    """Return the body of a `## {heading}` section of llms.txt, or None if absent."""
+    lines = llms_txt.splitlines(keepends=True)
+    start = next((idx + 1 for idx, line in enumerate(lines) if line.strip() == f"## {heading}"), None)
+    if start is None:
+        return None
+    end = next((idx for idx in range(start, len(lines)) if lines[idx].startswith("## ")), len(lines))
+    return "".join(lines[start:end]).strip("\n")
+
+
+def _write_section_index(target_dir: Path, subdir: str, llms_txt: str) -> None:
+    """Write references/{subdir}/index.md from the matching llms.txt section.
+
+    The section preserves llms.txt's category groupings and page titles, with links to
+    the pages we mirror locally rewritten to relative paths. Links to pages we don't
+    download (section roots, non-`.md` pages) are dropped.
+    """
+    heading = subdir.capitalize()
+    body = _llms_section_body(llms_txt, heading)
+    if not body:
+        return
+
+    def _localize(match: re.Match[str]) -> str:
+        url, section = match.group(0), match.group(1)
+        if section != subdir:
+            return url  # link into another section; left absolute so it is dropped below
+        # Keep the path under the section so nested pages stay nested (functions/foo.md).
+        return "./" + url.split(f"/docs/{section}/", 1)[1]
+
+    localized = _DOC_URL_RE.sub(_localize, body)
+    # Drop entries still pointing at absolute URLs (i.e. pages we didn't mirror locally).
+    kept = [line for line in localized.splitlines() if "](http" not in line]
+    index_dir = target_dir / "references" / subdir
+    index_dir.mkdir(parents=True, exist_ok=True)
+    (index_dir / "index.md").write_text(f"# {heading}\n\n" + "\n".join(kept).strip("\n") + "\n")
+
+
+def _replace_existing_target(target_dir: Path) -> None:
+    if target_dir.is_dir() and not target_dir.is_symlink():
+        shutil.rmtree(target_dir)
+    else:
+        target_dir.unlink()
+
+
+def _http_session():
+    import aiohttp
+
+    return aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=_DOCS_DOWNLOAD_TIMEOUT))
+
+
+async def _fetch_text(session, url: str) -> str:
+    async with session.get(url) as response:
+        response.raise_for_status()
+        return await response.text()
+
+
+async def _download_doc(session, target_dir: Path, url: str) -> Exception | None:
+    try:
+        content = await _fetch_text(session, url)
+        output_path = _doc_resource_path(target_dir, url)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(content)
+    except Exception as exc:
+        return exc
+    return None
+
+
+async def _download_docs(target_dir: Path) -> None:
+    async with _http_session() as session:
+        try:
+            llms_txt = await _fetch_text(session, _LLMS_TXT_URL)
+        except Exception as exc:
+            suffix = f": {str(exc)}" if str(exc) else ""
+            click.echo(f"Warning: could not download Modal documentation{suffix}", err=True)
+            return
+
+        urls = _extract_doc_urls(llms_txt)
+        semaphore = asyncio.Semaphore(_DOCS_DOWNLOAD_CONCURRENCY)
+
+        async def _download_with_limit(url: str) -> Exception | None:
+            async with semaphore:
+                return await _download_doc(session, target_dir, url)
+
+        failures = await asyncio.gather(*(_download_with_limit(url) for url in urls))
+
+    failed = [(url, failure) for url, failure in zip(urls, failures) if failure is not None]
+    failed_count = len(failed)
+    if failed_count:
+        failed_url, failure = failed[0]
+        click.echo(
+            f"Warning: failed to download {failed_count} of {len(urls)} Modal documentation resources. "
+            f"First failure: {failed_url}: {failure}",
+            err=True,
+        )
+
+    for subdir in ("guide", "examples"):
+        _write_section_index(target_dir, subdir, llms_txt)
+
+
+def _generate_api_reference_docs(target_dir: Path) -> None:
+    """Generate the API reference locally from the installed client into references/api/.
+
+    Introspecting the installed `modal` package keeps the reference in sync with the
+    user's SDK version and removes the network dependency for this section.
+    """
+    import contextlib
+    import io
+    import warnings
+
+    try:
+        from modal_docs.gen_reference_docs import run
+    except Exception as exc:
+        click.echo(f"Warning: could not generate Modal API reference: {exc}", err=True)
+        return
+
+    api_dir = target_dir / "references" / "api"
+    with tempfile.TemporaryDirectory() as raw_dir:
+        # TODO(michael): doc generation is very noisy by default; make it configurable
+        with (
+            warnings.catch_warnings(),
+            contextlib.redirect_stdout(io.StringIO()),
+            contextlib.redirect_stderr(io.StringIO()),
+        ):
+            warnings.simplefilter("ignore")
+            run(raw_dir)
+
+        api_dir.mkdir(parents=True, exist_ok=True)
+        for raw_file in Path(raw_dir).glob("*.md"):
+            content = raw_file.read_text()
+            # Strip the leading mdsvex `<script>` block; it is website-only boilerplate.
+            if content.startswith("<script>"):
+                content = content.partition("</script>\n")[2].lstrip("\n")
+            (api_dir / raw_file.name).write_text(content)
+
+
+def _install_or_update(*, claude: bool, global_install: bool, no_docs: bool, yes: bool, update: bool) -> None:
+    target_dir = _target_dir(claude=claude, global_install=global_install)
+    action = "Updating" if update else "Installing"
+    completed_action = "Updated" if update else "Installed"
+    output_manager = OutputManager.get()
+
+    target_exists = target_dir.exists() or target_dir.is_symlink()
+    if target_exists:
+        target_has_modal_skill = _target_has_modal_skill(target_dir)
+        if not yes and not (update and target_has_modal_skill):
+            confirm_or_suggest_yes(f"Replace existing content at {target_dir}?")
+    elif update and not yes:
+        confirm_or_suggest_yes(f"No existing Modal skill found at {target_dir}. Install it there?")
+
+    print_logo()
+
+    # Build the output in a tmp directory so final installation is atomic.
+    target_dir.parent.mkdir(parents=True, exist_ok=True)
+    staging_dir = Path(tempfile.mkdtemp(dir=target_dir.parent, prefix=".modal-skill-"))
+    try:
+        with output_manager.status(f"{action} Modal skill..."):
+            (staging_dir / "SKILL.md").write_text(_skill_content_for_install())
+        if not no_docs:
+            with output_manager.status("Downloading Modal documentation..."):
+                asyncio.run(_download_docs(staging_dir))
+                _generate_api_reference_docs(staging_dir)
+
+        if target_exists:
+            _replace_existing_target(target_dir)
+        staging_dir.rename(target_dir)
+    finally:
+        if staging_dir.exists():
+            shutil.rmtree(staging_dir, ignore_errors=True)
+
+    output_manager.print(f"[{GREEN}]✓[/{GREEN}] {completed_action} Modal skill to {target_dir}", highlight=False)
+
+
+def _install_options(func):
+    func = click.option("--claude", is_flag=True, default=False, help="Install to .claude/ rather than .agents/.")(func)
+    func = click.option(
+        "-g", "--global", "global_install", is_flag=True, default=False, help="Install in the user home directory."
+    )(func)
+    func = click.option(
+        "--no-docs",
+        is_flag=True,
+        default=False,
+        help="Skip downloading Modal documentation resources.",
+    )(func)
+    return yes_option(func)
+
+
+@skills_cli.command("install", help="Install Modal skills.")
+@_install_options
+def install(*, claude: bool, global_install: bool, no_docs: bool, yes: bool):
+    _install_or_update(claude=claude, global_install=global_install, no_docs=no_docs, yes=yes, update=False)
+
+
+@skills_cli.command("update", help="Update installed Modal skills.")
+@_install_options
+def update(*, claude: bool, global_install: bool, no_docs: bool, yes: bool):
+    _install_or_update(claude=claude, global_install=global_install, no_docs=no_docs, yes=yes, update=True)
+
+
+@skills_cli.command("show", help="Print Modal skill content to the terminal.")
+def show():
+    click.echo(_skill_content_for_install(), nl=False)

{modal-1.4.4.dev15 → modal-1.4.4.dev16}/modal/client.pyi

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