deepagents-cli 0.0.27__tar.gz → 0.0.28__tar.gz

{deepagents_cli-0.0.27 → deepagents_cli-0.0.28}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.0.28](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.27...deepagents-cli==0.0.28) (2026-03-05)
+
+### Features
+
+* Add video support to multimodal inputs ([#1521](https://github.com/langchain-ai/deepagents/issues/1521)) ([f9b49b7](https://github.com/langchain-ai/deepagents/commit/f9b49b7341bd42b5278a03496743e4709689598e))
+* Add NVIDIA api key support and default model ([#1577](https://github.com/langchain-ai/deepagents/issues/1577)) ([9ce2660](https://github.com/langchain-ai/deepagents/commit/9ce2660a67c3497cff18d27131fb7ef49e85b310))
+* Fuzzy search for slash command autocomplete ([#1660](https://github.com/langchain-ai/deepagents/issues/1660)) ([5f6e9c0](https://github.com/langchain-ai/deepagents/commit/5f6e9c014e6a99783b3113184cc12f0179a902f0))
+* Tab autocomplete in model selector ([#1669](https://github.com/langchain-ai/deepagents/issues/1669)) ([28bd0aa](https://github.com/langchain-ai/deepagents/commit/28bd0aaca737b8bb194ecb9f6612989b9aacec02))
+
+### Bug Fixes
+
+* Backspace at cursor position 0 exits mode even with text ([#1666](https://github.com/langchain-ai/deepagents/issues/1666)) ([dfa4c1f](https://github.com/langchain-ai/deepagents/commit/dfa4c1fedcecf2bb17d8ffef01cf50efe6c80fb0))
+* Skip auto-approve toggle when modal screen is open ([#1668](https://github.com/langchain-ai/deepagents/issues/1668)) ([6597f0b](https://github.com/langchain-ai/deepagents/commit/6597f0b8da3c3bd701a42e228660d459cefe3f64))
+* Truncate model name in status bar on narrow terminals ([#1665](https://github.com/langchain-ai/deepagents/issues/1665)) ([0e24a04](https://github.com/langchain-ai/deepagents/commit/0e24a04aa9e5894735522ce23295bb27fd2b8190))
+
 ## [0.0.27](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.26...deepagents-cli==0.0.27) (2026-03-04)
 
 ### Features

{deepagents_cli-0.0.27 → deepagents_cli-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.27
+Version: 0.0.28
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/

deepagents_cli-0.0.28/deepagents_cli/_version.py

@@ -0,0 +1,3 @@
+"""Version information for `deepagents-cli`."""
+
+__version__ = "0.0.28"  # x-release-please-version

{deepagents_cli-0.0.27 → deepagents_cli-0.0.28}/deepagents_cli/app.py

@@ -497,9 +497,9 @@ class DeepAgentsApp(App):
         self._message_store = MessageStore()
         # Lazily imported here to avoid pulling image dependencies into
         # argument parsing paths.
-        from deepagents_cli.input import ImageTracker
+        from deepagents_cli.input import MediaTracker
 
-        self._image_tracker = ImageTracker()
+        self._image_tracker = MediaTracker()
 
     def compose(self) -> ComposeResult:
         """Compose the application layout.
@@ -2484,6 +2484,10 @@ class DeepAgentsApp(App):
         web search, URL fetch) run without prompting. Updates the status
         bar indicator and session state.
         """
+        # shift+tab is reused for navigation inside modal screens (e.g.
+        # ModelSelectorScreen); skip the toggle so it doesn't fire through.
+        if isinstance(self.screen, ModalScreen):
+            return
         self._auto_approve = not self._auto_approve
         if self._status_bar:
             self._status_bar.set_auto_approve(enabled=self._auto_approve)
@@ -2892,7 +2896,10 @@ class DeepAgentsApp(App):
         # Post-swap: update UI and save config
         display = f"{settings.model_provider}:{settings.model_name}"
         if self._status_bar:
-            self._status_bar.set_model(display)
+            self._status_bar.set_model(
+                provider=settings.model_provider or "",
+                model=settings.model_name or "",
+            )
 
         config_saved = save_recent_model(display)
         if config_saved:

{deepagents_cli-0.0.27 → deepagents_cli-0.0.28}/deepagents_cli/config.py

@@ -383,6 +383,7 @@ class Settings:
         openai_api_key: OpenAI API key if available.
         anthropic_api_key: Anthropic API key if available.
         google_api_key: Google API key if available.
+        nvidia_api_key: NVIDIA API key if available.
         tavily_api_key: Tavily API key if available.
         google_cloud_project: Google Cloud project ID for VertexAI
             authentication.
@@ -401,6 +402,7 @@ class Settings:
     openai_api_key: str | None
     anthropic_api_key: str | None
     google_api_key: str | None
+    nvidia_api_key: str | None
     tavily_api_key: str | None
 
     # Google Cloud configuration (for VertexAI)
@@ -435,6 +437,7 @@ class Settings:
         openai_key = os.environ.get("OPENAI_API_KEY")
         anthropic_key = os.environ.get("ANTHROPIC_API_KEY")
         google_key = os.environ.get("GOOGLE_API_KEY")
+        nvidia_key = os.environ.get("NVIDIA_API_KEY")
         tavily_key = os.environ.get("TAVILY_API_KEY")
         google_cloud_project = os.environ.get("GOOGLE_CLOUD_PROJECT")
 
@@ -459,6 +462,7 @@ class Settings:
             openai_api_key=openai_key,
             anthropic_api_key=anthropic_key,
             google_api_key=google_key,
+            nvidia_api_key=nvidia_key,
             tavily_api_key=tavily_key,
             google_cloud_project=google_cloud_project,
             deepagents_langchain_project=deepagents_langchain_project,
@@ -482,6 +486,11 @@ class Settings:
         """Check if Google API key is configured."""
         return self.google_api_key is not None
 
+    @property
+    def has_nvidia(self) -> bool:
+        """Check if NVIDIA API key is configured."""
+        return self.nvidia_api_key is not None
+
     @property
     def has_vertex_ai(self) -> bool:
         """Check if VertexAI is available (Google Cloud project set, no API key).
@@ -1084,8 +1093,9 @@ def detect_provider(model_name: str) -> str | None:
         model_name: Model name to detect provider from.
 
     Returns:
-        Provider name (openai, anthropic, google_genai, google_vertexai) or
-            `None` if the provider cannot be determined from the name alone.
+        Provider name (openai, anthropic, google_genai, google_vertexai,
+            nvidia) or `None` if the provider cannot be determined from the
+            name alone.
     """
     model_lower = model_name.lower()
 
@@ -1102,6 +1112,9 @@ def detect_provider(model_name: str) -> str | None:
             return "google_vertexai"
         return "google_genai"
 
+    if model_lower.startswith(("nemotron", "nvidia/")):
+        return "nvidia"
+
     return None
 
 
@@ -1135,11 +1148,13 @@ def _get_default_model_spec() -> str:
         return "google_genai:gemini-3.1-pro-preview"
     if settings.has_vertex_ai:
         return "google_vertexai:gemini-3.1-pro-preview"
+    if settings.has_nvidia:
+        return "nvidia:nvidia/nemotron-3-nano-30b-a3b"
 
     msg = (
         "No credentials configured. Please set one of: "
         "ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY, "
-        "or GOOGLE_CLOUD_PROJECT"
+        "GOOGLE_CLOUD_PROJECT, or NVIDIA_API_KEY"
     )
     raise ModelConfigError(msg)
 
@@ -1309,6 +1324,7 @@ def _create_model_via_init(
             "openai": "langchain-openai",
             "google_genai": "langchain-google-genai",
             "google_vertexai": "langchain-google-vertexai",
+            "nvidia": "langchain-nvidia-ai-endpoints",
         }
         package = package_map.get(provider, f"langchain-{provider}")
         msg = (

{deepagents_cli-0.0.27 → deepagents_cli-0.0.28}/deepagents_cli/input.py

@@ -1,14 +1,15 @@
-"""Input handling utilities including image tracking and file mention parsing."""
+"""Input handling utilities including image/video tracking and file mention parsing."""
 
 import logging
 import re
 import shlex
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Literal
 from urllib.parse import unquote, urlparse
 
 from deepagents_cli.config import console
-from deepagents_cli.image_utils import ImageData
+from deepagents_cli.media_utils import ImageData, VideoData
 
 logger = logging.getLogger(__name__)
 
@@ -52,6 +53,9 @@ in `UserMessage.compose()` additionally checks `start == 0` before styling
 slash commands, so a `/` mid-string is not highlighted.
 """
 
+MediaKind = Literal["image", "video"]
+"""Accepted values for the `kind` parameter in `MediaTracker` methods."""
+
 IMAGE_PLACEHOLDER_PATTERN = re.compile(r"\[image (?P<id>\d+)\]")
 """Pattern for image placeholders with a named `id` capture group.
 
@@ -59,6 +63,13 @@ Used to extract numeric IDs from placeholder tokens so the tracker can prune
 stale entries and compute the next available ID.
 """
 
+VIDEO_PLACEHOLDER_PATTERN = re.compile(r"\[video (?P<id>\d+)\]")
+"""Pattern for video placeholders with a named `id` capture group.
+
+Used to extract numeric IDs from placeholder tokens so the tracker can prune
+stale entries and compute the next available ID.
+"""
+
 _UNICODE_SPACE_EQUIVALENTS = str.maketrans(
     {
         "\u00a0": " ",  # NO-BREAK SPACE
@@ -91,32 +102,76 @@ class ParsedPastedPathPayload:
     token_end: int | None = None
 
 
-class ImageTracker:
-    """Track pasted images in the current conversation."""
+class MediaTracker:
+    """Track pasted images and videos in the current conversation."""
 
     def __init__(self) -> None:
-        """Initialize an empty image tracker.
+        """Initialize an empty media tracker.
 
-        Sets up an empty list to store images and initializes the ID counter
-        to 1 for generating unique placeholder identifiers.
+        Sets up empty lists to store images and videos, and initializes the
+        ID counters to 1 for generating unique placeholder identifiers.
         """
         self.images: list[ImageData] = []
-        self.next_id = 1
+        self.videos: list[VideoData] = []
+        self.next_image_id: int = 1
+        self.next_video_id: int = 1
+
+    def add_media(self, data: ImageData | VideoData, kind: MediaKind) -> str:
+        """Add a media item and return its placeholder text.
+
+        Args:
+            data: The image or video data to track.
+            kind: Media type key.
+
+        Returns:
+            Placeholder string like "[image 1]" or "[video 1]".
+        """
+        if kind == "image":
+            placeholder = f"[image {self.next_image_id}]"
+            data.placeholder = placeholder
+            self.images.append(data)  # type: ignore[arg-type]
+            self.next_image_id += 1
+        else:
+            placeholder = f"[video {self.next_video_id}]"
+            data.placeholder = placeholder
+            self.videos.append(data)  # type: ignore[arg-type]
+            self.next_video_id += 1
+        return placeholder
 
     def add_image(self, image_data: ImageData) -> str:
         """Add an image and return its placeholder text.
 
         Args:
-            image_data: The image data to track
+            image_data: The image data to track.
 
         Returns:
-            Placeholder string like "[image 1]"
+            Placeholder string like "[image 1]".
         """
-        placeholder = f"[image {self.next_id}]"
-        image_data.placeholder = placeholder
-        self.images.append(image_data)
-        self.next_id += 1
-        return placeholder
+        return self.add_media(image_data, "image")
+
+    def add_video(self, video_data: VideoData) -> str:
+        """Add a video and return its placeholder text.
+
+        Args:
+            video_data: The video data to track.
+
+        Returns:
+            Placeholder string like "[video 1]".
+        """
+        return self.add_media(video_data, "video")
+
+    def get_media(self, kind: MediaKind) -> list[ImageData] | list[VideoData]:
+        """Get all tracked media of a given type.
+
+        Args:
+            kind: Media type key.
+
+        Returns:
+            Copy of the list of tracked media items.
+        """
+        if kind == "image":
+            return list(self.images)
+        return list(self.videos)
 
     def get_images(self) -> list[ImageData]:
         """Get all tracked images.
@@ -124,39 +179,94 @@ class ImageTracker:
         Returns:
             Copy of the list of tracked images.
         """
-        return self.images.copy()
+        return list(self.images)
+
+    def get_videos(self) -> list[VideoData]:
+        """Get all tracked videos.
+
+        Returns:
+            Copy of the list of tracked videos.
+        """
+        return list(self.videos)
 
     def clear(self) -> None:
-        """Clear all tracked images and reset counter."""
+        """Clear all tracked media and reset counters."""
         self.images.clear()
-        self.next_id = 1
+        self.videos.clear()
+        self.next_image_id = 1
+        self.next_video_id = 1
 
     def sync_to_text(self, text: str) -> None:
-        """Retain only images still referenced by placeholders in current text.
+        """Retain only media still referenced by placeholders in current text.
 
         Args:
             text: Current input text shown to the user.
         """
-        placeholders = {
-            match.group(0) for match in IMAGE_PLACEHOLDER_PATTERN.finditer(text)
-        }
-        if not placeholders:
+        img_found = self._sync_kind_images(text)
+        vid_found = self._sync_kind_videos(text)
+        if not img_found and not vid_found:
             self.clear()
-            return
 
+    def _sync_kind_images(self, text: str) -> bool:
+        """Sync image list to surviving placeholders in text.
+
+        Args:
+            text: Current input text.
+
+        Returns:
+            Whether any image placeholders were found.
+        """
+        placeholders = {m.group(0) for m in IMAGE_PLACEHOLDER_PATTERN.finditer(text)}
         self.images = [img for img in self.images if img.placeholder in placeholders]
         if not self.images:
-            self.next_id = 1
-            return
+            self.next_image_id = 1
+        else:
+            self.next_image_id = self._max_placeholder_id(
+                self.images, IMAGE_PLACEHOLDER_PATTERN, len(self.images)
+            )
+        return bool(placeholders)
 
-        max_id = 0
-        for image in self.images:
-            match = IMAGE_PLACEHOLDER_PATTERN.fullmatch(image.placeholder)
-            if match is None:
-                continue
-            max_id = max(max_id, int(match.group("id")))
+    def _sync_kind_videos(self, text: str) -> bool:
+        """Sync video list to surviving placeholders in text.
+
+        Args:
+            text: Current input text.
+
+        Returns:
+            Whether any video placeholders were found.
+        """
+        placeholders = {m.group(0) for m in VIDEO_PLACEHOLDER_PATTERN.finditer(text)}
+        self.videos = [vid for vid in self.videos if vid.placeholder in placeholders]
+        if not self.videos:
+            self.next_video_id = 1
+        else:
+            self.next_video_id = self._max_placeholder_id(
+                self.videos, VIDEO_PLACEHOLDER_PATTERN, len(self.videos)
+            )
+        return bool(placeholders)
+
+    @staticmethod
+    def _max_placeholder_id(
+        items: list[ImageData] | list[VideoData],
+        pattern: re.Pattern[str],
+        fallback_count: int,
+    ) -> int:
+        """Compute next ID from the highest surviving placeholder.
+
+        Args:
+            items: Surviving media items.
+            pattern: Placeholder regex with an `id` group.
+            fallback_count: Fallback when no IDs can be parsed.
 
-        self.next_id = max_id + 1 if max_id else len(self.images) + 1
+        Returns:
+            Next ID value (max_id + 1).
+        """
+        max_id = 0
+        for item in items:
+            match = pattern.fullmatch(item.placeholder)
+            if match is not None:
+                max_id = max(max_id, int(match.group("id")))
+        return max_id + 1 if max_id else fallback_count + 1
 
 
 def parse_file_mentions(text: str) -> tuple[str, list[Path]]:

deepagents_cli-0.0.27/deepagents_cli/image_utils.py → deepagents_cli-0.0.28/deepagents_cli/media_utils.py

@@ -1,4 +1,4 @@
-"""Utilities for handling image paste from clipboard."""
+"""Utilities for handling image and video media from clipboard and files."""
 
 import base64
 import io
@@ -12,9 +12,43 @@ import subprocess  # noqa: S404
 import sys
 import tempfile
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langchain_core.messages.content import VideoContentBlock
 
 logger = logging.getLogger(__name__)
 
+IMAGE_EXTENSIONS: frozenset[str] = frozenset(
+    {
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".bmp",
+        ".tiff",
+        ".tif",
+        ".webp",
+        ".ico",
+    }
+)
+"""Common image file extensions supported by PIL."""
+
+VIDEO_EXTENSIONS: frozenset[str] = frozenset(
+    {
+        ".mp4",
+        ".mov",
+        ".avi",
+        ".webm",
+        ".m4v",
+        ".wmv",
+    }
+)
+"""Video file extensions with validated magic-byte support."""
+
+MAX_MEDIA_BYTES: int = 20 * 1024 * 1024
+"""Maximum media file size (20 MB). Keeps base64 payload under ~27 MB."""
+
 
 def _get_executable(name: str) -> str | None:
     """Get full path to an executable using shutil.which().
@@ -48,6 +82,28 @@ class ImageData:
         }
 
 
+@dataclass
+class VideoData:
+    """Represents a pasted video with its base64 encoding."""
+
+    base64_data: str
+    format: str  # "mp4", "quicktime", etc.
+    placeholder: str  # Display text like "[video 1]"
+
+    def to_message_content(self) -> "VideoContentBlock":
+        """Convert to LangChain `VideoContentBlock` format.
+
+        Returns:
+            `VideoContentBlock` with base64 data and mime_type.
+        """
+        from langchain_core.messages.content import create_video_block
+
+        return create_video_block(
+            base64=self.base64_data,
+            mime_type=f"video/{self.format}",
+        )
+
+
 def get_clipboard_image() -> ImageData | None:
     """Attempt to read an image from the system clipboard.
 
@@ -79,6 +135,19 @@ def get_image_from_path(path: pathlib.Path) -> ImageData | None:
     from PIL import Image, UnidentifiedImageError
 
     try:
+        file_size = path.stat().st_size
+        if file_size == 0:
+            logger.debug("Image file is empty: %s", path)
+            return None
+        if file_size > MAX_MEDIA_BYTES:
+            logger.warning(
+                "Image file %s is too large (%d MB, max %d MB)",
+                path,
+                file_size // (1024 * 1024),
+                MAX_MEDIA_BYTES // (1024 * 1024),
+            )
+            return None
+
         image_bytes = path.read_bytes()
         if not image_bytes:
             return None
@@ -95,7 +164,7 @@ def get_image_from_path(path: pathlib.Path) -> ImageData | None:
             image_format = "png"
 
         return ImageData(
-            base64_data=encode_image_to_base64(image_bytes),
+            base64_data=encode_to_base64(image_bytes),
             format=image_format,
             placeholder="[image]",
         )
@@ -104,6 +173,105 @@ def get_image_from_path(path: pathlib.Path) -> ImageData | None:
         return None
 
 
+def _detect_video_format(data: bytes) -> str | None:
+    """Detect video MIME subtype from magic bytes.
+
+    Args:
+        data: Raw file bytes (at least 12 bytes for reliable detection).
+
+    Returns:
+        MIME subtype (e.g. "mp4", "webm") or `None` if unrecognized.
+    """
+    min_avi_len = 12
+    if data[4:8] == b"ftyp":
+        # ftyp box: major brand at bytes 8-12 distinguishes MOV vs MP4
+        brand = data[8:12]
+        if brand == b"qt  ":
+            return "quicktime"
+        return "mp4"
+    if data[:4] == b"RIFF" and len(data) >= min_avi_len and data[8:12] == b"AVI ":
+        return "avi"
+    if data[:4] == b"\x30\x26\xb2\x75":  # ASF/WMV
+        return "x-ms-wmv"
+    if data[:4] == b"\x1a\x45\xdf\xa3":  # WebM/Matroska (EBML header)
+        return "webm"
+    return None
+
+
+def get_video_from_path(path: pathlib.Path) -> VideoData | None:
+    """Read and encode a video file from disk.
+
+    Args:
+        path: Path to the video file.
+
+    Returns:
+        `VideoData` when the file is a valid video, otherwise `None`.
+    """
+    suffix = path.suffix.lower()
+    if suffix not in VIDEO_EXTENSIONS:
+        return None
+
+    try:
+        file_size = path.stat().st_size
+        if file_size == 0:
+            logger.debug("Video file is empty: %s", path)
+            return None
+        if file_size > MAX_MEDIA_BYTES:
+            logger.warning(
+                "Video file %s is too large (%d MB, max %d MB)",
+                path,
+                file_size // (1024 * 1024),
+                MAX_MEDIA_BYTES // (1024 * 1024),
+            )
+            return None
+
+        video_bytes = path.read_bytes()
+
+        # Validate it's a real video file by checking magic bytes
+        # MP4 starts with ftyp, MOV also uses ftyp, AVI starts with RIFF
+        min_video_len = 8
+        if len(video_bytes) < min_video_len:
+            logger.debug("Video file too small (%d bytes): %s", len(video_bytes), path)
+            return None
+
+        # Detect format from magic bytes (not extension) so renamed files
+        # get the correct MIME type.
+        detected_format = _detect_video_format(video_bytes)
+        if detected_format is None:
+            logger.warning(
+                "Video file %s has unrecognized signature for extension '%s'; "
+                "skipping. If this is a valid video, the format may not be "
+                "supported yet.",
+                path,
+                suffix,
+            )
+            return None
+
+        return VideoData(
+            base64_data=encode_to_base64(video_bytes),
+            format=detected_format,
+            placeholder="[video]",
+        )
+    except OSError as e:
+        logger.warning("Failed to load video from %s: %s", path, e, exc_info=True)
+        return None
+
+
+def get_media_from_path(path: pathlib.Path) -> ImageData | VideoData | None:
+    """Try to load a file as an image first, then as a video.
+
+    Args:
+        path: Path to the media file.
+
+    Returns:
+        `ImageData` or `VideoData` if the file is valid media, otherwise `None`.
+    """
+    result: ImageData | VideoData | None = get_image_from_path(path)
+    if result is not None:
+        return result
+    return get_video_from_path(path)
+
+
 def _get_macos_clipboard_image() -> ImageData | None:
     """Get clipboard image on macOS using pngpaste or osascript.
 
@@ -269,27 +437,30 @@ def _get_clipboard_via_osascript() -> ImageData | None:
             logger.debug("Failed to clean up temp file %s: %s", temp_path, e)
 
 
-def encode_image_to_base64(image_bytes: bytes) -> str:
-    """Encode image bytes to base64 string.
+def encode_to_base64(data: bytes) -> str:
+    """Encode raw bytes to a base64 string.
 
     Args:
-        image_bytes: Raw image bytes
+        data: Raw bytes to encode.
 
     Returns:
         Base64-encoded string.
     """
-    return base64.b64encode(image_bytes).decode("utf-8")
+    return base64.b64encode(data).decode("utf-8")
 
 
-def create_multimodal_content(text: str, images: list[ImageData]) -> list[dict]:
-    """Create multimodal message content with text and images.
+def create_multimodal_content(
+    text: str, images: list[ImageData], videos: list[VideoData] | None = None
+) -> list[dict]:
+    """Create multimodal message content with text, images, and videos.
 
     Args:
         text: Text content of the message
         images: List of ImageData objects
+        videos: Optional list of VideoData objects
 
     Returns:
-        List of content blocks in LangChain format.
+        List of content blocks in LangChain message format.
     """
     content_blocks = []
 
@@ -300,4 +471,8 @@ def create_multimodal_content(text: str, images: list[ImageData]) -> list[dict]:
     # Add image blocks
     content_blocks.extend(image.to_message_content() for image in images)
 
+    # Add video blocks
+    if videos:
+        content_blocks.extend(video.to_message_content() for video in videos)
+
     return content_blocks