utim-cli 2.0.1__tar.gz → 2.0.3__tar.gz

{utim_cli-2.0.1 → utim_cli-2.0.3}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.0.3] - 2026-08-04
+
+### 🛠️ Fixes
+- **Fixed `Wrong color format 'dim'` crash in marketplace TUI**: `prompt_toolkit` does not accept the `dim` modifier as a free-floating token before a color, nor `class:dim` as a literal inline style. All `f"dim {_MUTED}"` / `f"dim {_FG}"` style strings in `utim_cli/tui/marketplace_dialog.py` have been rewritten to `f"fg:{_MUTED}"` / `f"fg:{_FG}"`, and the `[dim]…[/dim]` markup parser now drops the `dim` token instead of emitting the unsafe `class:dim` class string. `/marketplace` no longer crashes on Windows when rendering info/hint/status rows.
+
+## [2.0.2] - 2026-08-04
+
+### 🛠️ Fixes
+- Minor bug fixes.
+
 ## [2.0.1] - 2026-08-04 - Bugfix & Adaptive Iteration Budget
 
 ### 🛠️ Fixes

{utim_cli-2.0.1/utim_cli.egg-info → utim_cli-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.0.1
+Version: 2.0.3
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.0.1 → utim_cli-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.0.1"
+version = "2.0.3"
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
 requires-python = ">=3.9"

{utim_cli-2.0.1 → utim_cli-2.0.3}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.0.1"
+    __version__ = "2.0.3"
 
 import builtins, os, pathlib, urllib.parse, re
 

{utim_cli-2.0.1 → utim_cli-2.0.3}/utim_cli/_version.py

@@ -11,4 +11,4 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.0.1"
+VERSION = "2.0.3"

{utim_cli-2.0.1 → utim_cli-2.0.3}/utim_cli/orchestrator.py

@@ -3429,6 +3429,7 @@ class Orchestrator:
                 results[orig_idx] = (tc, "[Aborted by user]")
                 continue
             _tools_module._cancel_event = self.cancel_event
+            _tools_module._active_model_id = self.model_id
             result = self._execute_tool_timed(tc)
             self._current_line_len = 0
             results[orig_idx] = (tc, result)
@@ -3684,81 +3685,6 @@ class Orchestrator:
         self._persist_messages()
         return res
 
-    def _filter_active_tools(self, all_tools: List[Dict], messages: List[Dict]) -> List[Dict]:
-        """Semantic Intent Tool Masking with Self-Healing Task Re-hydration.
-
-        Core coding tools and MCP tools are ALWAYS active. Specialized tools
-        (analyze_image, generate_image, plan_project, create_skill, background_tasks)
-        are activated via broad semantic intent detection (synonyms, implicit requests,
-        file paths) and persistently retained once activated during the task session.
-        """
-        if not all_tools:
-            return all_tools
-
-        if not hasattr(self, "_activated_specialized_tools"):
-            self._activated_specialized_tools = set()
-
-        CORE_TOOLS = {
-            "read_file", "write_file", "edit_file", "move_file", "delete_file",
-            "run_command", "list_directory", "grep_search", "search", "search_codebase",
-            "recall_experience", "store_experience", "manage_memory"
-        }
-
-        # Broad semantic intent patterns (handles slang, implicit desires, multi-language phrasing)
-        SEMANTIC_INTENT_PATTERNS = {
-            "analyze_image": [
-                r"\.(png|jpg|jpeg|webp|gif|bmp|svg|tiff|ico)\b",
-                r"(?i)\b(image|img|screenshot|photo|picture|diagram|fig|figure|ui|mockup|wireframe|visual|inspect|look at|see|show|crop|icon|logo|asset)\b"
-            ],
-            "generate_image": [
-                r"(?i)\b(generate|draw|create|paint|render|make|design|build)\b.*\b(image|picture|photo|illustration|graphic|logo|banner|art|ui|mockup|icon|asset|cover|poster|avatar)\b",
-                r"(?i)\b(text to image|image gen|sd|flux|dall-e|midjourney|prompt expander)\b"
-            ],
-            "plan_project": [
-                r"(?i)\b(plan|architect|roadmap|milestone|phases|breakdown|strategy|design system|structure repo|project structure|todo list|task list|multi-step|workflow|steps)\b",
-                r"(?i)\b(how should (i|we)|what is the best (way|architecture|structure)|organize this)\b"
-            ],
-            "create_skill": [
-                r"(?i)\b(skill|custom tool|reusable prompt|workflow template|save routine|workspace rule|automation|agent skill)\b"
-            ],
-            "background_tasks": [
-                r"(?i)\b(background|task|bg|daemon|long running|process|job|async|monitor|poll|kill task)\b"
-            ]
-        }
-
-        # Collect text across recent messages (user + assistant reasoning + tool outputs)
-        recent_text_parts = []
-        for m in (messages[-8:] if messages else []):
-            content = m.get("content")
-            if isinstance(content, str):
-                recent_text_parts.append(content)
-            elif isinstance(content, list):
-                for part in content:
-                    if isinstance(part, dict) and part.get("type") == "text":
-                        recent_text_parts.append(part.get("text", ""))
-
-        combined_text = "\n".join(recent_text_parts)
-
-        # 1. Semantic intent detection
-        for tool_name, patterns in SEMANTIC_INTENT_PATTERNS.items():
-            for pat in patterns:
-                if re.search(pat, combined_text):
-                    self._activated_specialized_tools.add(tool_name)
-                    break
-
-        # 2. Re-hydrate if iteration count >= 3 (complex multi-step task automatically gets plan_project)
-        if getattr(self, "current_iteration", 0) >= 3:
-            self._activated_specialized_tools.add("plan_project")
-
-        # 3. Filter all_tools
-        filtered = []
-        for t in all_tools:
-            name = t.get("function", {}).get("name", "")
-            if name in CORE_TOOLS or name not in SEMANTIC_INTENT_PATTERNS or name in self._activated_specialized_tools:
-                filtered.append(t)
-
-        return filtered
-
     # ── Context compression ──────────────────────────────────────────────────
 
     @staticmethod
@@ -4909,30 +4835,6 @@ class Orchestrator:
                 # No extra newline here - let the next block handle it
                 pass
 
-            # ── Self-Healing Re-Activation Gate ──────────────────────────────
-            # If native tool_calls are empty and the model expresses inability to find a tool,
-            # or mentions a specialized tool by name, immediately unmask ALL specialized tools
-            # and re-prompt the model in 0ms so it NEVER gets stuck or stops.
-            SPECIALIZED_TOOLS_ALL = {"analyze_image", "generate_image", "plan_project", "create_skill", "background_tasks"}
-            if not tool_calls and content and not _attempted_tool_call:
-                content_lower = content.lower()
-                mentioned_specialized = {t for t in SPECIALIZED_TOOLS_ALL if t in content_lower}
-                lacks_tool_signal = any(phrase in content_lower for phrase in [
-                    "don't have", "do not have", "cannot access", "no tool", "tool is missing",
-                    "unable to generate", "unable to analyze", "not available", "don't see"
-                ])
-                if mentioned_specialized or lacks_tool_signal:
-                    if not hasattr(self, "_activated_specialized_tools"):
-                        self._activated_specialized_tools = set()
-                    self._activated_specialized_tools.update(SPECIALIZED_TOOLS_ALL)
-                    
-                    self.messages.append({"role": "assistant", "content": content})
-                    self.messages.append({
-                        "role": "user",
-                        "content": "[SYSTEM DIRECTIVE] All specialized tools (analyze_image, generate_image, plan_project, create_skill, background_tasks) have been fully unmasked and loaded into your active tool schema. Please re-run immediately using the required tool."
-                    })
-                    continue
-
             # Parse text-based tool calls fallback if native tool calls are empty
             if not tool_calls and content:
                 parsed_calls = []
@@ -5520,6 +5422,11 @@ class Orchestrator:
                     + result[-tail_chars:]
                     + (f"\n\n{_line_hint}" if _line_hint else "")
                 )
+
+            # Clear any stale vision images from a previous iteration before
+            # this batch of tools runs (defensive — shouldn't normally be set).
+            _tools_module._pending_vision_images.clear()
+
             # Execute tools in parallel when beneficial
             if len(tool_calls) > 1:
                 # Use parallel execution for multiple tools
@@ -5536,50 +5443,14 @@ class Orchestrator:
                     func_name = tc.get("function", {}).get("name", "")
                     result = _cap_tool_result(func_name, result)
 
-                    # If result is an [Image: path] marker and model is vision-capable,
-                    # inject the actual image as multimodal content
-                    _img_match = __import__("re").match(r"^\[Image:\s+(.+)\]$", result.strip())
-                    if _img_match and func_name in ("read_file",):
-                        try:
-                            from utim_cli.tools import is_model_vision_capable
-                            if is_model_vision_capable():
-                                _img_path = _img_match.group(1)
-                                _multimodal = _tool_result_to_multimodal(result, _img_path)
-                                self.messages.append(
-                                    {
-                                        "role": "tool",
-                                        "tool_call_id": tc_id,
-                                        "name": func_name,
-                                        "content": _multimodal,
-                                    }
-                                )
-                            else:
-                                self.messages.append(
-                                    {
-                                        "role": "tool",
-                                        "tool_call_id": tc_id,
-                                        "name": func_name,
-                                        "content": result,
-                                    }
-                                )
-                        except Exception:
-                            self.messages.append(
-                                {
-                                    "role": "tool",
-                                    "tool_call_id": tc_id,
-                                    "name": func_name,
-                                    "content": result,
-                                }
-                            )
-                    else:
-                        self.messages.append(
-                            {
-                                "role": "tool",
-                                "tool_call_id": tc_id,
-                                "name": func_name,
-                                "content": result,
-                            }
-                        )
+                    self.messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tc_id,
+                            "name": func_name,
+                            "content": result,
+                        }
+                    )
             else:
                 # Single tool - execute directly
                 for tc in tool_calls:
@@ -5588,55 +5459,41 @@ class Orchestrator:
                         
                     func_name = tc.get("function", {}).get("name", "")
                     _tools_module._cancel_event = self.cancel_event
+                    _tools_module._active_model_id = self.model_id
                     result = self._execute_tool_timed(tc)
                     self._current_line_len = 0
                     tc_id = tc.get("id") or str(tc.get("index", "0"))
                     result = _cap_tool_result(func_name, result)
 
-                    # If result is an [Image: path] marker and model is vision-capable,
-                    # inject the actual image as multimodal content
-                    _img_match = __import__("re").match(r"^\[Image:\s+(.+)\]$", result.strip())
-                    if _img_match and func_name in ("read_file",):
-                        try:
-                            from utim_cli.tools import is_model_vision_capable
-                            if is_model_vision_capable():
-                                _img_path = _img_match.group(1)
-                                _multimodal = _tool_result_to_multimodal(result, _img_path)
-                                self.messages.append(
-                                    {
-                                        "role": "tool",
-                                        "tool_call_id": tc_id,
-                                        "name": func_name,
-                                        "content": _multimodal,
-                                    }
-                                )
-                            else:
-                                self.messages.append(
-                                    {
-                                        "role": "tool",
-                                        "tool_call_id": tc_id,
-                                        "name": func_name,
-                                        "content": result,
-                                    }
-                                )
-                        except Exception:
-                            self.messages.append(
-                                {
-                                    "role": "tool",
-                                    "tool_call_id": tc_id,
-                                    "name": func_name,
-                                    "content": result,
-                                }
-                            )
-                    else:
-                        self.messages.append(
-                            {
-                                "role": "tool",
-                                "tool_call_id": tc_id,
-                                "name": func_name,
-                                "content": result,
-                            }
-                        )
+                    self.messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tc_id,
+                            "name": func_name,
+                            "content": result,
+                        }
+                    )
+
+            # ── Vision image injection ────────────────────────────────────────
+            # read_file encodes image bytes and pushes them to
+            # _tools_module._pending_vision_images so they bypass the tool-result
+            # string pipeline entirely.  Drain the queue here (after ALL tools in
+            # this iteration have run) and inject each image as a "user" message
+            # — the only role that providers universally accept image_url content in.
+            _vision_queue = getattr(_tools_module, "_pending_vision_images", [])
+            if _vision_queue:
+                for _vimg in list(_vision_queue):
+                    self.messages.append(
+                        {
+                            "role": "user",
+                            "content": [
+                                {"type": "text", "text": f"[Image from read_file: {_vimg['meta']}]"},
+                                {"type": "image_url", "image_url": {"url": f"data:{_vimg['mime']};base64,{_vimg['b64']}"}},
+                            ],
+                        }
+                    )
+                _vision_queue.clear()
+
             # --- Repeated Tool Failure Loop Detection ---
             if not hasattr(self, "_tool_failure_counts"):
                 self._tool_failure_counts = {}

{utim_cli-2.0.1 → utim_cli-2.0.3}/utim_cli/tools.py

@@ -159,27 +159,36 @@ def resolve_project_path(filepath: str) -> str:
 _VISION_MODELS_CACHE = None
 
 def is_model_vision_capable(model_id: str = None) -> bool:
-    """Determine if a model is vision-capable based on models.txt architecture input_modalities."""
+    """Determine if a model is vision-capable (Vision: True/False) based on MODEL_REGISTRY and models.txt input_modalities."""
     global _VISION_MODELS_CACHE
     if not model_id:
-        try:
-            from utim_cli.config import config
-            model_id = config.get("model") or config.get("active_model") or "google/gemini-3.5-flash-lite"
-        except Exception:
-            model_id = "google/gemini-3.5-flash-lite"
+        # Prefer the slot injected by the orchestrator; fall back to config as last resort.
+        model_id = _active_model_id or ""
+        if not model_id:
+            try:
+                from utim_cli.config import config
+                model_id = config.get("main_model") or config.get("model") or ""
+            except Exception:
+                model_id = ""
 
-    model_id_str = str(model_id).lower().strip()
+    model_id_str = str(model_id).strip()
+    if not model_id_str:
+        return False  # unknown model → treat as non-vision (safe default)
 
-    # Quick keyword match for known vision families
-    vision_keywords = [
-        "gemini", "claude", "gpt-5", "gpt-4", "grok", "qwen3.7", "qwen3.6",
-        "inkling", "kimi", "muse-spark", "krea", "vision", "-vl", "llava", "pixtral"
-    ]
-    if any(kw in model_id_str for kw in vision_keywords):
-        if not any(non_v in model_id_str for non_v in ["text-only", "coder-air", "kat-coder"]):
-            return True
+    model_id_lower = model_id_str.lower()
+
+    # 1. Check server MODEL_REGISTRY first
+    try:
+        from utim_cli.server.models import MODEL_REGISTRY
+        if model_id_str in MODEL_REGISTRY:
+            return MODEL_REGISTRY[model_id_str].vision
+        for k, entry in MODEL_REGISTRY.items():
+            if k.lower() == model_id_lower:
+                return entry.vision
+    except Exception:
+        pass
 
-    # Lazy-load models.txt mapping
+    # 2. Build / query models.txt cache (authoritative list from OpenRouter metadata)
     if _VISION_MODELS_CACHE is None:
         _VISION_MODELS_CACHE = {}
         try:
@@ -190,15 +199,27 @@ def is_model_vision_capable(model_id: str = None) -> bool:
                 models_txt_path = "models.txt"
             if os.path.exists(models_txt_path):
                 with open(models_txt_path, "r", encoding="utf-8") as f:
-                    data = json.load(f).get("data", [])
-                for m in data:
-                    mid = m.get("id", "").lower()
-                    in_mods = m.get("architecture", {}).get("input_modalities", [])
-                    _VISION_MODELS_CACHE[mid] = ("image" in in_mods)
+                    data = json.load(f)
+                items = data.get("data", []) if isinstance(data, dict) else data
+                for m in items:
+                    mid = m.get("id", "")
+                    if not mid:
+                        continue
+                    in_mods = m.get("architecture", {}).get("input_modalities", []) or []
+                    _VISION_MODELS_CACHE[mid.lower()] = ("image" in in_mods)
         except Exception:
             _VISION_MODELS_CACHE = {}
 
-    return _VISION_MODELS_CACHE.get(model_id_str, False)
+    if model_id_lower in _VISION_MODELS_CACHE:
+        return _VISION_MODELS_CACHE[model_id_lower]
+
+    # 3. Fallback for custom / unlisted model names
+    vision_keywords = ["vision", "-vl", "llava", "pixtral", "image", "multimodal", "gpt-4o", "gemini", "claude-3", "claude-4", "claude-5", "qwen3"]
+    if any(kw in model_id_lower for kw in vision_keywords):
+        if not any(non_v in model_id_lower for non_v in ["text-only", "coder-air", "kat-coder"]):
+            return True
+
+    return False
 
 
 def _extract_file_symbols(filepath: str, file_content: str) -> list:
@@ -305,15 +326,125 @@ def read_file(filepath: str, start_line: int = None, end_line: int = None, symbo
     ext = _os.path.splitext(filepath)[1].lower()
     image_extensions = {'.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp'}
     if ext in image_extensions:
-        # Vision-capable models can see the image directly — no need for a text
-        # description that clutters the tool indicator. Non-vision models still
-        # need the description as their only way to "see" the image.
+        # Collect image metadata (size, dimensions) for the text portion of the response.
         try:
-            if is_model_vision_capable():
-                return f"[Image: {filepath}]"
+            file_size = _os.path.getsize(filepath)
+            size_kb = file_size / 1024.0
+            size_str = f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb/1024:.2f} MB"
+        except Exception:
+            size_str = "unknown size"
+
+        meta = f"[Image: {_os.path.basename(filepath)} | {ext.lstrip('.').upper()} | {size_str} | URI: {_make_file_uri(filepath)}]"
+
+        # Try to also read image dimensions (pure stdlib where possible, else Pillow)
+        dim_str = ""
+        try:
+            with open(filepath, "rb") as _f:
+                _head = _f.read(64)
+            # PNG: width@16, height@20 (big-endian uint32)
+            if _head.startswith(b"\x89PNG\r\n\x1a\n") and len(_head) >= 24:
+                import struct
+                w, h = struct.unpack(">II", _head[16:24])
+                dim_str = f" | {w}x{h}px"
+            # GIF: width@6, height@8 (little-endian uint16)
+            elif _head.startswith(b"GIF8") and len(_head) >= 10:
+                import struct
+                w, h = struct.unpack("<HH", _head[6:10])
+                dim_str = f" | {w}x{h}px"
+            # JPEG: parse SOF marker to find dimensions
+            elif _head.startswith(b"\xff\xd8\xff"):
+                import struct
+                _f2 = open(filepath, "rb")
+                try:
+                    soi = _f2.read(2)
+                    while True:
+                        marker = _f2.read(2)
+                        if len(marker) < 2:
+                            break
+                        if marker[0] != 0xFF:
+                            break
+                        # Skip SOI / EOI / RST markers
+                        if marker[1] in (0xD8, 0xD9) or 0xD0 <= marker[1] <= 0xD7:
+                            continue
+                        seg_len_bytes = _f2.read(2)
+                        if len(seg_len_bytes) < 2:
+                            break
+                        seg_len = struct.unpack(">H", seg_len_bytes)[0]
+                        # SOFn markers (Start of Frame): 0xC0-0xCF except 0xC4,0xC8,0xCC
+                        if 0xC0 <= marker[1] <= 0xCF and marker[1] not in (0xC4, 0xC8, 0xCC):
+                            _f2.read(1)  # precision
+                            h, w = struct.unpack(">HH", _f2.read(4))
+                            dim_str = f" | {w}x{h}px"
+                            break
+                        else:
+                            _f2.read(seg_len - 2)
+                finally:
+                    _f2.close()
+            # WebP: 'RIFF....WEBP' then VP8 / VP8L / VP8X chunk
+            elif _head.startswith(b"RIFF") and _head[8:12] == b"WEBP":
+                with open(filepath, "rb") as _f3:
+                    _f3.read(12)
+                    chunk_hdr = _f3.read(4)
+                    if chunk_hdr == b"VP8 ":
+                        _f3.read(10)  # frame tag + start code
+                        w = int.from_bytes(_f3.read(2), "little") & 0x3FFF
+                        h = int.from_bytes(_f3.read(2), "little") & 0x3FFF
+                        dim_str = f" | {w}x{h}px"
+                    elif chunk_hdr == b"VP8L":
+                        _f3.read(1)  # signature byte
+                        b1, b2, b3, b4 = _f3.read(4)
+                        w = ((b2 & 0x3F) << 8 | b1) + 1
+                        h = (((b4 & 0x0F) << 10) | (b3 << 2) | ((b2 & 0xC0) >> 6)) + 1
+                        dim_str = f" | {w}x{h}px"
+                    elif chunk_hdr == b"VP8X":
+                        _f3.read(8)
+                        w = int.from_bytes(_f3.read(3), "little") + 1
+                        h = int.from_bytes(_f3.read(3), "little") + 1
+                        dim_str = f" | {w}x{h}px"
         except Exception:
             pass
-        return analyze_image(filepath, "Identify and describe this image in detail, listing any people, actors, characters, text, UI elements, colors, and visual layout.")
+
+        meta += dim_str
+
+        # Route image to model based on vision capability:
+        #
+        # Vision-capable model → encode bytes here, push to _pending_vision_images.
+        #   The orchestrator drains this queue after all tools complete and injects a
+        #   "user" message with the raw base64 image so the model truly sees it.
+        #   (image_url blocks are NOT supported inside "tool" role messages by most
+        #   providers — they must live in a "user" message.)
+        #
+        # Non-vision model → call analyze_image() in the background and return its
+        #   text description so the model has useful context.
+        if is_model_vision_capable():
+            import base64 as _b64mod, mimetypes as _mtmod
+            _mime_v, _ = _mtmod.guess_type(filepath)
+            _ext_v = _os.path.splitext(filepath)[1].lower()
+            if not _mime_v or not _mime_v.startswith("image/"):
+                _mime_v = f"image/{_ext_v[1:]}"
+                if _ext_v == ".jpg":
+                    _mime_v = "image/jpeg"
+            try:
+                with open(filepath, "rb") as _fv:
+                    _b64_v = _b64mod.b64encode(_fv.read()).decode("utf-8")
+                # Push to queue — orchestrator injects the user message after tools complete
+                _pending_vision_images.append({"meta": meta, "b64": _b64_v, "mime": _mime_v})
+                return meta  # return clean metadata text only; no sentinel needed
+            except Exception as _venc_err:
+                # Encoding failed — fall through to analyze_image text fallback below
+                pass
+
+        # Non-vision model (or encoding failed): describe image via external vision sub-model.
+        try:
+            description = analyze_image(
+                filepath,
+                "Identify and describe this image in detail, listing any people, actors, characters, "
+                "text, UI elements, colors, visual layout, code or terminal output shown, and any "
+                "visible error messages or stack traces verbatim."
+            )
+            return f"{meta}\n{description}"
+        except Exception as _e2:
+            return f"{meta}\n(Vision description unavailable: {_e2})"
 
     try:
         with open(filepath, "rb") as f:
@@ -967,6 +1098,17 @@ def edit_file(filepath: str, old_str: str = None, new_str: str = None, replaceme
 # threading.Event here before each tool call so run_command can be aborted.
 _cancel_event = None   # type: threading.Event | None
 
+# Active model ID slot — injected by the orchestrator before each tool call
+# (same pattern as _cancel_event). read_file reads this to decide whether to
+# push image bytes to _pending_vision_images or call analyze_image instead.
+_active_model_id: str = ""
+
+# Queue for vision images: read_file pushes here when the active model is
+# vision-capable; the orchestrator drains it after each tool-call batch and
+# injects a "user" message containing the raw image bytes so the model can
+# actually see the image (most providers reject image_url in "tool" messages).
+_pending_vision_images: list = []  # list of {"meta": str, "b64": str, "mime": str}
+
 # ─── Intelligent Sandbox mode ──────────────────────────────────────────────────
 # Set to True via --sandbox CLI flag. When active, run_command uses static analysis
 # to check commands for safety. Risky commands are blocked unless approved.