meshapi-code 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

meshapi/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.0"
+__version__ = "0.4.2"

meshapi/attachments.py

@@ -0,0 +1,150 @@
+"""Image attachment loading for multimodal chat.
+
+Builds OpenAI-compatible content parts (`{type: image_url, image_url: {url,
+detail}}`) from local file paths or HTTP(S) URLs. We always base64-encode
+into a `data:image/...;base64,...` URL — the Mesh API docs warn that some
+providers refuse public URLs and require base64, so always-base64 is the
+maximally-compatible default.
+
+Also provides a conservative auto-detector for the main loop: scan a user
+prompt for tokens that unambiguously look like image paths or URLs (start
+with `/`, `~`, `./`, `../`, or `http(s)://`, end in a known image extension),
+so a dragged-in file path can be attached without an explicit slash command.
+"""
+import base64
+import mimetypes
+from pathlib import Path
+from urllib.parse import urlparse
+
+import httpx
+
+# Size guardrails. We don't refuse — vision tokens are the user's call — but we
+# do report sizes back so the user sees the cost.
+HARD_LIMIT_BYTES = 20 * 1024 * 1024  # 20 MB
+
+IMAGE_EXTS = (".png", ".jpg", ".jpeg", ".gif", ".webp")
+IMAGE_MIMES = {"image/png", "image/jpeg", "image/gif", "image/webp"}
+
+
+class AttachmentError(Exception):
+    """Raised for any user-facing failure to attach an image."""
+
+
+def load_image(source: str, detail: str = "auto") -> tuple[dict, dict]:
+    """Load an image from a local path or URL into a content part.
+
+    Returns (content_part, info):
+      - content_part is the dict to splice into the message's `content` array:
+        `{"type":"image_url","image_url":{"url":"data:...","detail":...}}`
+      - info has display metadata: `{"name", "size_bytes", "mime"}`
+
+    Raises AttachmentError on any failure (not found, too big, wrong MIME,
+    network error). Caller is expected to surface the message to the user.
+    """
+    if _looks_like_url(source):
+        data, mime, name = _fetch_url(source)
+    else:
+        data, mime, name = _read_local(source)
+
+    if len(data) > HARD_LIMIT_BYTES:
+        raise AttachmentError(
+            f"image too large: {len(data) // (1024*1024)} MB "
+            f"(limit {HARD_LIMIT_BYTES // (1024*1024)} MB)"
+        )
+
+    b64 = base64.b64encode(data).decode("ascii")
+    data_url = f"data:{mime};base64,{b64}"
+    return (
+        {"type": "image_url", "image_url": {"url": data_url, "detail": detail}},
+        {"name": name, "size_bytes": len(data), "mime": mime},
+    )
+
+
+def find_image_tokens(text: str) -> list[str]:
+    """Return tokens in `text` that look like image paths or URLs.
+
+    Conservative on purpose — only matches:
+      - http(s) URLs ending in a known image extension
+      - Local paths starting with `/`, `~/`, `./`, or `../` (and ending in an
+        image extension, AND pointing at an existing file)
+
+    Bare filenames (`foo.png`) are NOT matched: too ambiguous with filenames
+    mentioned in conversation. Tokens wrapped in backticks or quotes are
+    skipped (user's escape hatch).
+
+    Trailing sentence punctuation (`.,;:!?)`) is trimmed before matching.
+    """
+    matches: list[str] = []
+    for raw in text.split():
+        if not raw or raw[0] in "`\"'":
+            continue
+        token = raw
+        while token and token[-1] in ".,;:!?)":
+            token = token[:-1]
+        if not token:
+            continue
+        low = token.lower()
+        if low.startswith(("http://", "https://")):
+            path_part = token.split("?", 1)[0]
+            if path_part.lower().endswith(IMAGE_EXTS):
+                matches.append(token)
+            continue
+        if token.startswith(("/", "~/", "./", "../")):
+            if low.endswith(IMAGE_EXTS):
+                try:
+                    p = Path(token).expanduser()
+                    if p.is_file():
+                        matches.append(token)
+                except OSError:
+                    pass
+    return matches
+
+
+def _looks_like_url(s: str) -> bool:
+    try:
+        u = urlparse(s)
+    except (ValueError, AttributeError):
+        return False
+    return u.scheme in ("http", "https") and bool(u.netloc)
+
+
+def _fetch_url(url: str) -> tuple[bytes, str, str]:
+    try:
+        with httpx.Client(timeout=30, follow_redirects=True) as client:
+            r = client.get(url)
+            r.raise_for_status()
+            data = r.content
+            mime = r.headers.get("content-type", "").split(";")[0].strip()
+    except httpx.HTTPError as e:
+        raise AttachmentError(f"couldn't fetch {url}: {e}") from None
+
+    if not mime:
+        guessed, _ = mimetypes.guess_type(url)
+        mime = guessed or ""
+    if mime not in IMAGE_MIMES:
+        raise AttachmentError(
+            f"URL doesn't look like an image (mime: {mime or 'unknown'})"
+        )
+    name = Path(urlparse(url).path).name or "image"
+    return data, mime, name
+
+
+def _read_local(path_str: str) -> tuple[bytes, str, str]:
+    path = Path(path_str).expanduser()
+    if not path.exists():
+        raise AttachmentError(f"file not found: {path}")
+    if not path.is_file():
+        raise AttachmentError(f"not a regular file: {path}")
+    mime, _ = mimetypes.guess_type(str(path))
+    if not mime:
+        raise AttachmentError(f"couldn't determine MIME type for {path.name}")
+    if mime not in IMAGE_MIMES:
+        raise AttachmentError(
+            f"{path.name} isn't an image (mime: {mime}). "
+            "For text documents, use /file."
+        )
+    try:
+        data = path.read_bytes()
+    except OSError as e:
+        raise AttachmentError(f"can't read {path}: {e}") from None
+    return data, mime, path.name

meshapi/cli.py

@@ -23,6 +23,7 @@ from rich.markup import escape as _rich_escape
 from rich.text import Text
 
 from . import __version__, statusbar
+from .attachments import AttachmentError, find_image_tokens, load_image
 from .client import stream_chat
 from .commands import handle_command
 from .config import CONFIG_FILE, HISTORY_FILE, load_config, secure_file
@@ -681,6 +682,7 @@ def main() -> None:
         "mode": from_str(args.mode),
         "plan": None,    # populated by the model via create_plan
         "servers": [],   # background processes spawned via start_server
+        "pending_attachments": [],  # image content parts queued via /image
     }
 
     # Mode cycle — used by both the prompt-toolkit keybinding (while at the
@@ -786,7 +788,40 @@ def main() -> None:
                 break
             continue
 
-        state["messages"].append({"role": "user", "content": user_input})
+        # Auto-detect image paths/URLs in the prompt and attach them. Tokens
+        # that look like unambiguous image paths (start with /, ~, ./, ../,
+        # or http(s)://) and end in a known image extension are pulled out
+        # and replaced with "[Image #N]" so the text reads naturally.
+        auto_text = user_input
+        auto_parts: list = []
+        queued = state.get("pending_attachments") or []
+        n_offset = len(queued)
+        for token in find_image_tokens(user_input):
+            if token not in auto_text:
+                continue  # already replaced (duplicate mention)
+            try:
+                part, info = load_image(token)
+            except AttachmentError as e:
+                console.print(f"[yellow]Couldn't auto-attach {token}: {e}[/yellow]")
+                continue
+            n = n_offset + len(auto_parts) + 1
+            auto_text = auto_text.replace(token, f"[Image #{n}]")
+            auto_parts.append(part)
+            size_kb = max(1, info["size_bytes"] // 1024)
+            console.print(
+                f"[{CODE}]📎 attached {info['name']} ({size_kb} KB, {info['mime']})[/{CODE}]"
+            )
+
+        all_parts = queued + auto_parts
+        if all_parts:
+            console.print(f"[dim]→ sending {len(all_parts)} image(s) with this prompt[/dim]")
+            state["messages"].append({
+                "role": "user",
+                "content": [{"type": "text", "text": auto_text}] + all_parts,
+            })
+            state["pending_attachments"] = []
+        else:
+            state["messages"].append({"role": "user", "content": user_input})
         console.print()
 
         # Tool-calling loop: keep streaming until model returns text without

meshapi/commands.py

@@ -3,9 +3,10 @@ from pathlib import Path
 
 from rich.panel import Panel
 
+from .attachments import AttachmentError, load_image
 from .config import save_config
 from .permissions import LABELS, Mode, from_str
-from .render import console, fmt_usd
+from .render import CODE, console, fmt_usd
 from .tools import build_system_prompt
 
 ROUTES = {"cheapest", "fastest", "balanced"}
@@ -55,6 +56,35 @@ def handle_command(cmd: str, state: dict) -> bool:
         else:
             console.print(f"[red]File not found: {path}[/red]")
 
+    elif name == "/image":
+        if not arg:
+            queued = state.get("pending_attachments") or []
+            if not queued:
+                console.print(
+                    "[dim]/image <path-or-url>  attach an image to the next prompt[/dim]"
+                )
+            else:
+                console.print(f"[dim]{len(queued)} image(s) queued for next prompt[/dim]")
+        else:
+            try:
+                part, info = load_image(arg.strip())
+            except AttachmentError as e:
+                console.print(f"[red]Can't attach: {e}[/red]")
+            else:
+                state.setdefault("pending_attachments", []).append(part)
+                size_kb = max(1, info["size_bytes"] // 1024)
+                console.print(
+                    f"[{CODE}]📎 attached {info['name']} ({size_kb} KB, {info['mime']})[/{CODE}]"
+                )
+
+    elif name == "/clear-attach":
+        had = len(state.get("pending_attachments") or [])
+        state["pending_attachments"] = []
+        if had:
+            console.print(f"[dim]Dropped {had} queued attachment(s).[/dim]")
+        else:
+            console.print("[dim]Nothing queued.[/dim]")
+
     elif name == "/system":
         if arg:
             state["cfg"]["system"] = arg
@@ -79,15 +109,20 @@ def handle_command(cmd: str, state: dict) -> bool:
 
     elif name == "/help":
         console.print(Panel.fit(
-            "/exit             end session\n"
-            "/clear            reset conversation\n"
-            "/model <name>     switch model (e.g. anthropic/claude-sonnet-4.5)\n"
-            "/route <mode>     cheapest|fastest|balanced|default\n"
-            "/mode <perm>      ask|bypass|none  (or shift+tab to cycle)\n"
-            "/file <path>      add file to context\n"
-            "/system <txt>     set system prompt\n"
-            "/cost             show session spend\n"
-            "/help             show this",
+            "/exit              end session\n"
+            "/clear             reset conversation\n"
+            "/model <name>      switch model (e.g. anthropic/claude-sonnet-4.5)\n"
+            "/route <mode>      cheapest|fastest|balanced|default\n"
+            "/mode <perm>       ask|bypass|none  (or shift+tab to cycle)\n"
+            "/file <path>       add text file to context\n"
+            "/image <path|url>  attach an image (base64) to the next prompt\n"
+            "/clear-attach      drop any queued image attachments\n"
+            "/system <txt>      set system prompt\n"
+            "/cost              show session spend\n"
+            "/help              show this\n\n"
+            "[dim]Image paths in a prompt auto-attach: drop /path/img.png in your\n"
+            "input and it's sent as a base64 image part. Wrap in backticks to keep\n"
+            "it as text. Multiple images per prompt are supported.[/dim]",
             title="commands",
             border_style="cyan",
         ))

meshapi/tools.py

@@ -39,6 +39,9 @@ def build_system_prompt(cfg: dict) -> str:
         "pass flags like --yes, -y, or --no-input; interactive prompts will "
         "hang and time out. The shell timeout is 120s; if a command would "
         "take longer, break it into smaller pieces.\n\n"
+        "User messages may include images attached as multimodal content "
+        "parts (image_url with a data: or https: URL). Look at them carefully "
+        "and reference what you see when relevant.\n\n"
         "For long-running servers (dev servers like `npm run dev` / `vite` / "
         "`next dev`, `flask run`, `python -m http.server`, file watchers, etc.) "
         "use the start_server tool — NOT run_bash. run_bash will kill the "
@@ -209,6 +212,18 @@ def execute(name: str, arguments: dict) -> str:
         path = arguments.get("path")
         if not path:
             return "Error: read_file requires a `path` argument."
+        # Guard against reading an image as text — return a helpful message
+        # so the model directs the user to /image instead of looping on a
+        # utf-8 decode error.
+        suffix = Path(path).suffix.lower()
+        if suffix in (".png", ".jpg", ".jpeg", ".gif", ".webp"):
+            return (
+                f"Error: {Path(path).name} is an image file and read_file only "
+                "reads text. Tell the user to attach the image instead — either "
+                f"by typing `/image {path}` or by including the path in their "
+                "next prompt (auto-attach picks up paths starting with /, ~, "
+                "./, ../, or http(s)://)."
+            )
         try:
             return Path(path).expanduser().read_text()
         except Exception as e:

{meshapi_code-0.4.0.dist-info → meshapi_code-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi-code
-Version: 0.4.0
+Version: 0.4.2
 Summary: Terminal chat for Mesh API — OpenAI-compatible LLM gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://docs.meshapi.ai

meshapi_code-0.4.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+meshapi/__init__.py,sha256=6hfVa12Q-nXyUEXr6SyKpqPEDJW6vlRHyPxlA27PfTs,22
+meshapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+meshapi/attachments.py,sha256=Mpsxm66QT_cJV4TXlnYU23ZhFm4vdzFEyXDenXjxpEU,5475
+meshapi/cli.py,sha256=N2uqztGWVCP3z6_kkPKUieWIiTrg187LN5Zy5640e_k,37447
+meshapi/client.py,sha256=Rtc-8W9XncxPlV6qQ9I_c25BizyBHYNiIy8Eb3kSaEw,2920
+meshapi/commands.py,sha256=MdaXgpfWdkg0bDE-Q-ufin0Wivcu66LOlJ2nzdvNqco,5302
+meshapi/config.py,sha256=DKFljJh1DfSispptYA7mtJFBVMzE8MMyb5UvcelxwTY,2349
+meshapi/keywatcher.py,sha256=tWVSLWZY-p08CcOd10Xvf5TrMGfjDaKDzYJRSfe4kPo,8057
+meshapi/permissions.py,sha256=BPLYiPrlLR1js9k64szm9b11fXYx0ZZcQ2a08GLNRg8,1033
+meshapi/plan.py,sha256=JWgzm2Qtbdso7nnoR7K896d7n7ufwlhT-2F09PGXXKs,2561
+meshapi/render.py,sha256=VwgDbYSElwEJ0WhSMpRZ8Tw_EA0A09s8D4yVh_nUL3o,4737
+meshapi/statusbar.py,sha256=yqF6fzCaZMXMzUmX1vzmKWAMbCe_YRsbnA27meA3vaw,1361
+meshapi/tools.py,sha256=lL8oxj7uxCyojmRvgjlzZSxs-DoIc8fhxnhiuNfm3RA,13728
+meshapi_code-0.4.2.dist-info/METADATA,sha256=gCzLZHiASN2ljGD_CXxQpphNq5YKtWh4La50cxl69Tw,7595
+meshapi_code-0.4.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+meshapi_code-0.4.2.dist-info/entry_points.txt,sha256=ZCXZ_SgrhWIQEHSjAXz0pUlyGbIQKZ68vp_Cg1Y0rME,45
+meshapi_code-0.4.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+meshapi_code-0.4.2.dist-info/licenses/NOTICE,sha256=wF-6Apse4eVIOpbNP3WLtTaOJClNFK7Jok2BnUvSo9U,191
+meshapi_code-0.4.2.dist-info/RECORD,,

meshapi_code-0.4.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-meshapi/__init__.py,sha256=42STGor_9nKYXumfeV5tiyD_M8VdcddX7CEexmibPBk,22
-meshapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
-meshapi/cli.py,sha256=wLtLmRFgN9AQ7Z050I0hCfIQKcIgM3-kjy0CNcoq5Nw,35752
-meshapi/client.py,sha256=Rtc-8W9XncxPlV6qQ9I_c25BizyBHYNiIy8Eb3kSaEw,2920
-meshapi/commands.py,sha256=fc_qnTa_oZgn5CRQ7GrpUm1Zclmat4McLdEV5YX5Wvg,3662
-meshapi/config.py,sha256=DKFljJh1DfSispptYA7mtJFBVMzE8MMyb5UvcelxwTY,2349
-meshapi/keywatcher.py,sha256=tWVSLWZY-p08CcOd10Xvf5TrMGfjDaKDzYJRSfe4kPo,8057
-meshapi/permissions.py,sha256=BPLYiPrlLR1js9k64szm9b11fXYx0ZZcQ2a08GLNRg8,1033
-meshapi/plan.py,sha256=JWgzm2Qtbdso7nnoR7K896d7n7ufwlhT-2F09PGXXKs,2561
-meshapi/render.py,sha256=VwgDbYSElwEJ0WhSMpRZ8Tw_EA0A09s8D4yVh_nUL3o,4737
-meshapi/statusbar.py,sha256=yqF6fzCaZMXMzUmX1vzmKWAMbCe_YRsbnA27meA3vaw,1361
-meshapi/tools.py,sha256=6KXuoRW5-XwIkGfLd-v2Ylr7UqVePEOwZFyCP6CT20M,12825
-meshapi_code-0.4.0.dist-info/METADATA,sha256=qEXN-tvjfzPDGPck2aX_arFb74_eoCF3fHBUtp6MrU0,7595
-meshapi_code-0.4.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-meshapi_code-0.4.0.dist-info/entry_points.txt,sha256=ZCXZ_SgrhWIQEHSjAXz0pUlyGbIQKZ68vp_Cg1Y0rME,45
-meshapi_code-0.4.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-meshapi_code-0.4.0.dist-info/licenses/NOTICE,sha256=wF-6Apse4eVIOpbNP3WLtTaOJClNFK7Jok2BnUvSo9U,191
-meshapi_code-0.4.0.dist-info/RECORD,,