zjcode 0.0.3__tar.gz → 0.0.4__tar.gz

{zjcode-0.0.3 → zjcode-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zjcode
-Version: 0.0.3
+Version: 0.0.4
 Summary: Private-branded terminal coding agent forked from deepagents-code.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/

{zjcode-0.0.3 → zjcode-0.0.4}/deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.0.3"  # x-release-please-version
+__version__ = "0.0.4"  # x-release-please-version
 
 DISTRIBUTION_NAME = "zjcode"
 """Distribution (wheel/PyPI) name for this private-branded build.

{zjcode-0.0.3 → zjcode-0.0.4}/deepagents_code/input.py

@@ -4,6 +4,7 @@ import logging
 import re
 import shlex
 from dataclasses import dataclass, replace
+from datetime import datetime
 from difflib import SequenceMatcher
 from pathlib import Path
 from typing import Literal
@@ -59,20 +60,45 @@ 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.
+IMAGE_PLACEHOLDER_PATTERN = re.compile(
+    r"\[img_(?P<id>[0-9]+(?:_[0-9]+)?)\]"
+)
+"""Pattern for image placeholders (e.g. ``[img_20250115143022]``).
 
-Used to extract numeric IDs from placeholder tokens so the tracker can prune
-stale entries and compute the next available ID.
+The id is either a local timestamp ``YYYYMMDDHHMMSS`` or (in tests) a plain
+counter, optionally followed by ``_N`` to disambiguate same-second collisions.
 """
 
-VIDEO_PLACEHOLDER_PATTERN = re.compile(r"\[video (?P<id>\d+)\]")
-"""Pattern for video placeholders with a named `id` capture group.
+VIDEO_PLACEHOLDER_PATTERN = re.compile(
+    r"\[vid_(?P<id>[0-9]+(?:_[0-9]+)?)\]"
+)
+"""Pattern for video placeholders (e.g. ``[vid_20250115143022]``).
 
-Used to extract numeric IDs from placeholder tokens so the tracker can prune
-stale entries and compute the next available ID.
+Same id scheme as `IMAGE_PLACEHOLDER_PATTERN` but with a ``vid_`` prefix so
+images and videos never share an id namespace.
 """
 
+_MEDIA_PLACEHOLDER_PREFIX: dict[MediaKind, str] = {
+    "image": "img_",
+    "video": "vid_",
+}
+
+
+def _now_timestamp() -> str:
+    """Return the current local time formatted as ``YYYYMMDDHHMMSS``."""
+    return datetime.now().strftime("%Y%m%d%H%M%S")
+
+
+def _generate_media_id(kind: MediaKind) -> str:  # noqa: ARG001
+    """Generate a placeholder id for a new media attachment.
+
+    Exposed as a hook so tests can substitute a deterministic id generator
+    without patching `datetime`. ``kind`` is accepted for future
+    per-namespace override needs but the production path returns the same
+    timestamp for both images and videos.
+    """
+    return _now_timestamp()
+
 _UNICODE_SPACE_EQUIVALENTS = str.maketrans(
     {
         "\u00a0": " ",  # NO-BREAK SPACE
@@ -111,13 +137,11 @@ class MediaTracker:
     def __init__(self) -> None:
         """Initialize an empty media tracker.
 
-        Sets up empty lists to store images and videos, and initializes the
-        ID counters to 1 for generating unique placeholder identifiers.
+        Sets up empty lists to store images and videos. Placeholder IDs are now
+        derived from timestamps, so there is no per-tracker counter to keep.
         """
         self.images: list[ImageData] = []
         self.videos: list[VideoData] = []
-        self.next_image_id: int = 1
-        self.next_video_id: int = 1
 
     def add_media(
         self,
@@ -131,38 +155,55 @@ class MediaTracker:
         Args:
             data: The image or video data to track.
             kind: Media type key.
-            existing_text: Current draft text. Placeholder IDs already present
-                here are skipped so literal user text is not bound to new media.
+            existing_text: Current draft text. Placeholder tokens already
+                present there are skipped so literal user text is not rebound
+                to new media (a same-second collision falls through to a
+                ``_2`` / ``_3`` suffix).
 
         Returns:
-            Placeholder string like "[image 1]" or "[video 1]".
+            Placeholder string like ``[img_20250115143022]`` or
+            ``[vid_20250115143022]``. When the base timestamp is already used
+            in the current draft or by another tracked item, a ``_N`` suffix
+            is appended so every attachment gets a unique token.
         """
+        prefix = _MEDIA_PLACEHOLDER_PREFIX[kind]
+        base_id = _generate_media_id(kind)
+        existing = self._all_placeholders() | self._draft_placeholders(existing_text)
+        candidate = f"[{prefix}{base_id}]"
+        suffix = 2
+        while candidate in existing:
+            candidate = f"[{prefix}{base_id}_{suffix}]"
+            suffix += 1
+        data.placeholder = candidate
         if kind == "image":
-            while f"[image {self.next_image_id}]" in existing_text:
-                self.next_image_id += 1
-            placeholder = f"[image {self.next_image_id}]"
-            data.placeholder = placeholder
             self.images.append(data)  # ty: ignore[invalid-argument-type]
-            self.next_image_id += 1
         else:
-            while f"[video {self.next_video_id}]" in existing_text:
-                self.next_video_id += 1
-            placeholder = f"[video {self.next_video_id}]"
-            data.placeholder = placeholder
             self.videos.append(data)  # ty: ignore[invalid-argument-type]
-            self.next_video_id += 1
-        return placeholder
+        return candidate
+
+    def _all_placeholders(self) -> set[str]:
+        """Return placeholders currently held by this tracker."""
+        return {item.placeholder for item in (*self.images, *self.videos)}
+
+    @staticmethod
+    def _draft_placeholders(text: str) -> set[str]:
+        """Return every media placeholder token literally present in `text`."""
+        tokens: set[str] = set()
+        for pattern in (IMAGE_PLACEHOLDER_PATTERN, VIDEO_PLACEHOLDER_PATTERN):
+            tokens.update(match.group(0) for match in pattern.finditer(text))
+        return tokens
 
     def add_image(self, image_data: ImageData, *, existing_text: str = "") -> str:
         """Add an image and return its placeholder text.
 
         Args:
             image_data: The image data to track.
-            existing_text: Current draft text. Placeholder IDs already present
-                here are skipped so literal user text is not bound to new media.
+            existing_text: Current draft text. Placeholder tokens already
+                present there are skipped so literal user text is not bound to
+                new media.
 
         Returns:
-            Placeholder string like "[image 1]".
+            Placeholder string like ``[img_20250115143022]``.
         """
         return self.add_media(image_data, "image", existing_text=existing_text)
 
@@ -171,11 +212,12 @@ class MediaTracker:
 
         Args:
             video_data: The video data to track.
-            existing_text: Current draft text. Placeholder IDs already present
-                here are skipped so literal user text is not bound to new media.
+            existing_text: Current draft text. Placeholder tokens already
+                present there are skipped so literal user text is not bound to
+                new media.
 
         Returns:
-            Placeholder string like "[video 1]".
+            Placeholder string like ``[vid_20250115143022]``.
         """
         return self.add_media(video_data, "video", existing_text=existing_text)
 
@@ -196,19 +238,15 @@ class MediaTracker:
         return list(self.videos)
 
     def clear(self) -> None:
-        """Clear all tracked media and reset counters."""
+        """Clear all tracked media."""
         self.images.clear()
         self.videos.clear()
-        self.next_image_id = 1
-        self.next_video_id = 1
 
     def snapshot(self) -> "MediaTracker":
         """Return an independent copy of the currently tracked media."""
         tracker = MediaTracker()
         tracker.images = [replace(img) for img in self.images]
         tracker.videos = [replace(vid) for vid in self.videos]
-        tracker.next_image_id = self.next_image_id
-        tracker.next_video_id = self.next_video_id
         return tracker
 
     def restore(self, snapshot: "MediaTracker") -> None:
@@ -219,8 +257,6 @@ class MediaTracker:
         """
         self.images = [replace(img) for img in snapshot.images]
         self.videos = [replace(vid) for vid in snapshot.videos]
-        self.next_image_id = snapshot.next_image_id
-        self.next_video_id = snapshot.next_video_id
 
     def sync_to_text(
         self,
@@ -298,12 +334,6 @@ class MediaTracker:
         self._update_placeholder_spans(
             self.images, matches, text, previous_text, cursor_offset
         )
-        if not self.images:
-            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)
 
     def _sync_kind_videos(
@@ -329,12 +359,6 @@ class MediaTracker:
         self._update_placeholder_spans(
             self.videos, matches, text, previous_text, cursor_offset
         )
-        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)
 
     def _update_placeholder_spans(
@@ -440,29 +464,6 @@ class MediaTracker:
                 break
         return None
 
-    @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.
-
-        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]]:
     r"""Extract `@file` mentions and return the text with resolved file paths.

{zjcode-0.0.3 → zjcode-0.0.4}/deepagents_code/media_utils.py

@@ -52,6 +52,44 @@ VIDEO_EXTENSIONS: frozenset[str] = frozenset(
 MAX_MEDIA_BYTES: int = 20 * 1024 * 1024
 """Maximum media file size (20 MB). Keeps base64 payload under ~27 MB."""
 
+PASTED_MEDIA_DIR: pathlib.Path = pathlib.Path.home() / ".zjcode" / "pasted"
+"""Directory where pasted media is archived for local reference.
+
+Images pasted into the TUI are decoded and written here so the user can inspect
+or forward the original file later. The base64 payload is still what gets sent
+to the model; this local copy is purely an archive of what was pasted.
+"""
+
+
+def save_pasted_media(base64_data: str, stem: str, image_format: str) -> pathlib.Path | None:
+    """Persist a pasted media payload to `PASTED_MEDIA_DIR` as `<stem>.<ext>`.
+
+    Failures are logged and swallowed: the local archive is a convenience, not
+    a hard requirement. The caller keeps the in-memory base64 blob regardless.
+
+    Args:
+        base64_data: Base64-encoded media bytes (no data-URL prefix).
+        stem: File stem (typically the placeholder id such as
+            ``img_20250115143022``). Callers guarantee uniqueness within the
+            current draft.
+        image_format: Image format label (e.g. ``"png"``, ``"jpeg"``); used to
+            derive the file extension.
+
+    Returns:
+        The absolute path written on success, ``None`` when the write failed.
+    """
+    try:
+        PASTED_MEDIA_DIR.mkdir(parents=True, exist_ok=True)
+        extension = image_format.lower() or "png"
+        if extension == "jpeg":
+            extension = "jpg"
+        target = PASTED_MEDIA_DIR / f"{stem}.{extension}"
+        target.write_bytes(base64.b64decode(base64_data))
+    except (OSError, ValueError) as exc:
+        logger.warning("Failed to archive pasted media to %s: %s", PASTED_MEDIA_DIR, exc)
+        return None
+    return target
+
 
 def strip_media_placeholders(
     text: str,
@@ -61,7 +99,7 @@ def strip_media_placeholders(
 ) -> str:
     """Remove display-only media placeholders from user text.
 
-    Placeholders like `[image 1]` are inserted into the terminal input purely for
+    Placeholders like `[img_20250115143022]` are inserted into the terminal input purely for
     display; the actual media travels as structured content blocks. They must not
     leak into the canonical model-facing message or LangSmith trace as if the user
     typed them.
@@ -74,7 +112,7 @@ def strip_media_placeholders(
     Args:
         text: Raw user text that may contain media placeholders.
         placeholders: Exact placeholder tokens for the media actually attached to
-            this message (e.g. ``["[image 1]", "[video 1]"]``).
+            this message (e.g. ``["[img_20250115143022]", "[vid_20250115143022]"]``).
         placeholder_spans: Exact `(start, end)` spans for tracked display tokens
             in `text`, when known.
 
@@ -118,7 +156,7 @@ def strip_media_placeholders(
 
     # Only strip spaces/tabs (not newlines) so code indentation on lines after a
     # removed placeholder is preserved. A full .strip() would collapse
-    # "[image 1]\n    def foo():" to "def foo():", losing the leading indent.
+    # "[img_20250115143022]\n    def foo():" to "def foo():", losing the leading indent.
     cleaned = text
     for start, end in sorted(spans, reverse=True):
         cleaned = cleaned[:start] + cleaned[end:]
@@ -183,7 +221,7 @@ class ImageData:
 
     base64_data: str
     format: str  # "png", "jpeg", etc.
-    placeholder: str  # Display text like "[image 1]"
+    placeholder: str  # Display text like "[img_20250115143022]"
     placeholder_span: tuple[int, int] | None = None
 
     def to_message_content(self) -> dict:
@@ -204,7 +242,7 @@ class VideoData:
 
     base64_data: str
     format: str  # "mp4", "quicktime", etc.
-    placeholder: str  # Display text like "[video 1]"
+    placeholder: str  # Display text like "[vid_20250115143022]"
     placeholder_span: tuple[int, int] | None = None
 
     def to_message_content(self) -> "VideoContentBlock":
@@ -796,7 +834,7 @@ def create_multimodal_content(
     content_blocks = []
 
     # Add text block. Strip only the display-only placeholders bound to the media
-    # actually attached here (e.g. "[image 1]") so the canonical/model-facing text
+    # actually attached here (e.g. "[img_20250115143022]") so the canonical/model-facing text
     # never contains fake user-authored placeholder text. When a span is known,
     # text that merely resembles the schema is preserved exactly; without a span
     # `strip_media_placeholders` falls back to removing one occurrence per item,

{zjcode-0.0.3 → zjcode-0.0.4}/deepagents_code/model_config.py

@@ -4154,3 +4154,111 @@ def save_custom_provider(
 
     clear_caches()
     return True
+
+
+class ModelDiscoveryError(Exception):
+    """Raised when discovering models from a provider's `/models` endpoint fails.
+
+    The message is user-facing and safe to render verbatim in the TUI.
+    """
+
+
+def fetch_provider_models(
+    base_url: str,
+    api_key: str | None = None,
+    *,
+    timeout: float = 10.0,
+    include_retiring: bool = True,
+) -> list[str]:
+    """Fetch the list of available models from an OpenAI-compatible provider.
+
+    Calls `GET {base_url}/models` with a Bearer token when `api_key` is
+    provided. Filters out models whose `status` is `"Shutdown"` (a Volcengine
+    Ark extension); other providers usually omit the field, in which case all
+    models are kept.
+
+    Args:
+        base_url: Provider's OpenAI-compatible API base URL (with or without a
+            trailing slash).
+        api_key: Optional API key sent as `Authorization: Bearer <key>`.
+        timeout: Total request timeout in seconds.
+        include_retiring: When `False`, also drop models with `status="Retiring"`.
+
+    Returns:
+        Sorted list of unique model IDs.
+
+    Raises:
+        ModelDiscoveryError: If the request fails, the response is not
+            successful, or the payload cannot be parsed as an OpenAI-style
+            model list.
+    """
+    import httpx  # local import to avoid pulling httpx at module import time
+
+    if not base_url:
+        msg = "Base URL is required to discover models."
+        raise ModelDiscoveryError(msg)
+
+    url = base_url.rstrip("/") + "/models"
+    headers: dict[str, str] = {"Accept": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    try:
+        response = httpx.get(url, headers=headers, timeout=timeout)
+    except httpx.TimeoutException as exc:
+        msg = f"Request to {url} timed out after {timeout:.0f}s."
+        raise ModelDiscoveryError(msg) from exc
+    except httpx.HTTPError as exc:
+        msg = f"Could not reach {url}: {exc}"
+        raise ModelDiscoveryError(msg) from exc
+
+    if response.status_code == 401:  # noqa: PLR2004 -- HTTP status codes are self-documenting
+        msg = "Authentication failed (HTTP 401). Check the API key."
+        raise ModelDiscoveryError(msg)
+    if response.status_code == 403:  # noqa: PLR2004
+        msg = "Forbidden (HTTP 403). The API key may lack permission."
+        raise ModelDiscoveryError(msg)
+    if response.status_code == 404:  # noqa: PLR2004
+        msg = f"{url} returned 404. This provider may not expose /models."
+        raise ModelDiscoveryError(msg)
+    if response.status_code >= 400:  # noqa: PLR2004
+        msg = f"HTTP {response.status_code} from {url}: {response.text[:200]}"
+        raise ModelDiscoveryError(msg)
+
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        msg = f"{url} did not return JSON: {exc}"
+        raise ModelDiscoveryError(msg) from exc
+
+    # OpenAI shape: {"object": "list", "data": [{"id": ..., ...}, ...]}
+    # Some providers just return a bare list.
+    if isinstance(payload, dict):
+        data = payload.get("data", payload.get("models", []))
+    else:
+        data = payload
+
+    if not isinstance(data, list):
+        msg = "Unexpected /models response shape (expected list under 'data')."
+        raise ModelDiscoveryError(msg)
+
+    ids: set[str] = set()
+    for entry in data:
+        if isinstance(entry, str):
+            ids.add(entry)
+            continue
+        if not isinstance(entry, dict):
+            continue
+        model_id = entry.get("id") or entry.get("name") or entry.get("model")
+        if not isinstance(model_id, str) or not model_id:
+            continue
+        # Volcengine Ark surfaces lifecycle in `status`; hide retired entries.
+        status = entry.get("status")
+        if isinstance(status, str):
+            if status == "Shutdown":
+                continue
+            if not include_retiring and status == "Retiring":
+                continue
+        ids.add(model_id)
+
+    return sorted(ids)

{zjcode-0.0.3 → zjcode-0.0.4}/deepagents_code/tui/widgets/chat_input.py

@@ -1449,8 +1449,18 @@ class ChatTextArea(TextArea):
         if image is not None:
             event.prevent_default()
             event.stop()
-            # Add image to media tracker to get numbered placeholder
-            placeholder = self._chat_input_owner._image_tracker.add_image(image)
+            # Bind a timestamped placeholder before archiving so the local
+            # filename matches the token the user sees (e.g. img_YYYYMMDDHHMMSS).
+            existing_text = self.text
+            placeholder = self._chat_input_owner._image_tracker.add_image(
+                image, existing_text=existing_text
+            )
+            stem = placeholder.strip("[]")
+            from deepagents_code.media_utils import save_pasted_media
+
+            await asyncio.to_thread(
+                save_pasted_media, image.base64_data, stem, image.format
+            )
             # Insert placeholder at cursor position
             self.insert(placeholder)
             return