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

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

@@ -1,5 +1,10 @@
 # Changelog
 
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.0.1
+Version: 2.0.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.0.1"
+version = "2.0.2"
 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.2}/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.2"
 
 import builtins, os, pathlib, urllib.parse, re
 

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

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

{utim_cli-2.0.1 → utim_cli-2.0.2}/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.2}/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.

{utim_cli-2.0.1 → utim_cli-2.0.2}/utim_cli/tui/model_dialog.py

@@ -621,55 +621,53 @@ def _dialog_model_main(orchestrator, target="main"):
         if is_paid_plan:
             approved_set.update({
                 "anthropic/claude-sonnet-4.6",
+                "anthropic/claude-sonnet-4.5",
+                "anthropic/claude-sonnet-5",
+                "anthropic/claude-opus-4.5",
+                "anthropic/claude-opus-4.6",
+                "anthropic/claude-opus-4.7",
+                "anthropic/claude-opus-4.8",
+                "anthropic/claude-fable-5",
                 "inclusionai/ling-2.6-flash",
+                "inclusionai/ling-2.6-1t",
                 "xiaomi/mimo-v2.5",
                 "xiaomi/mimo-v2.5-pro",
                 "deepseek/deepseek-v4-flash",
+                "deepseek/deepseek-v4-flash-0731",
                 "deepseek/deepseek-v4-pro",
+                "deepseek/deepseek-r1",
                 "openai/gpt-5.5",
-                "inclusionai/ling-2.6-1t",
-                "moonshotai/kimi-k2.6",
+                "openai/gpt-5.4",
+                "openai/gpt-5.4-mini",
                 "openai/gpt-5.3-codex",
+                "moonshotai/kimi-k2.6",
+                "moonshotai/kimi-k2.7-code",
+                "moonshotai/kimi-k2.5",
+                "moonshotai/kimi-k3",
                 "google/gemini-3.1-pro-preview-customtools",
-                "openai/gpt-5.4",
+                "google/gemini-3.5-flash",
+                "google/gemini-3.6-flash",
                 "minimax/minimax-m2.7",
+                "minimax/minimax-m2.5",
+                "minimax/minimax-m3",
                 "kwaipilot/kat-coder-pro-v2",
                 "z-ai/glm-5.1",
-                "anthropic/claude-fable-5",
-                "nex-agi/nex-n2-pro",
-                "minimax/minimax-m3",
-                "moonshotai/kimi-k2.7-code",
-                "deepseek/deepseek-r1",
-                "x-ai/grok-4.3",
-                "google/gemini-3.5-flash",
-                "qwen/qwen3.7-max",
-                "stepfun/step-3.7-flash",
-                "thinkingmachines/inkling",
-                "moonshotai/kimi-k3",
-                "meta/muse-spark-1.1",
-            
-                "anthropic/claude-sonnet-4.5",
-                "anthropic/claude-sonnet-4.6",
-                "anthropic/claude-opus-4.5",
-                "anthropic/claude-opus-4.6",
-                "anthropic/claude-opus-4.7",
-                "anthropic/claude-opus-4.8",
-                "anthropic/claude-sonnet-5",
                 "z-ai/glm-5-turbo",
                 "z-ai/glm-4.7",
                 "z-ai/glm-5",
                 "z-ai/glm-5.2",
-                "qwen/qwen3.7-plus",
-                "qwen/qwen3.7-max",
-                "qwen/qwen3.6-plus",
-                "openai/gpt-5.4-mini",
-                "minimax/minimax-m2.5",
+                "nex-agi/nex-n2-pro",
+                "x-ai/grok-4.3",
                 "x-ai/grok-4.20",
                 "x-ai/grok-build-0.1",
-                "moonshotai/kimi-k2.5",
-                "google/gemini-3.6-flash",
+                "qwen/qwen3.7-max",
+                "qwen/qwen3.7-plus",
+                "qwen/qwen3.6-plus",
+                "stepfun/step-3.7-flash",
+                "thinkingmachines/inkling",
+                "meta/muse-spark-1.1",
                 "poolside/laguna-s-2.1:free",
-})
+            })
     elif target.startswith('subagent_') and target not in ('subagent_image_gen', 'subagent_blender_vision', 'subagent_analyze_image', 'subagent_blender_code'):
         approved_set = {
             DEFAULT_MODEL,
@@ -818,6 +816,7 @@ def _dialog_model_main(orchestrator, target="main"):
         "xiaomi/mimo-v2.5": (0, "Very low"),
         "xiaomi/mimo-v2.5-pro": (2, "Medium"),
         "deepseek/deepseek-v4-flash": (0, "Very low"),
+        "deepseek/deepseek-v4-flash-0731": (0, "Very low"),
         "deepseek/deepseek-v4-pro": (1, "Low"),
         "openai/gpt-5.5": (4, "Very high"),
         "inclusionai/ling-2.6-1t": (1, "Low"),
@@ -907,6 +906,7 @@ def _dialog_model_main(orchestrator, target="main"):
         "xiaomi/mimo-v2.5": ("Highly capable multimodal model by Xiaomi.", []),
         "xiaomi/mimo-v2.5-pro": ("Xiaomi flagship multimodal and reasoning model.", []),
         "deepseek/deepseek-v4-flash": ("Ultra-fast, cost-effective model by DeepSeek.", []),
+        "deepseek/deepseek-v4-flash-0731": ("DeepSeek V4 Flash 0731 — Ultra-fast MoE coding and reasoning model by DeepSeek.", []),
         "deepseek/deepseek-v4-pro": ("DeepSeek flagship MoE and reasoning model.", []),
         "openai/gpt-5.5": ("Next-gen frontier reasoning model by OpenAI.", []),
         "inclusionai/ling-2.6-1t": ("Large context agent model by InclusionAI.", []),
@@ -953,9 +953,7 @@ def _dialog_model_main(orchestrator, target="main"):
         "google/gemini-3.1-flash-image": ("Google stable image and multimodal vision model.", []),
         "openai/gpt-5-image-mini": ("OpenAI high-speed multimodal and image model.", []),
         "openai/gpt-image-2": ("OpenAI advanced image synthesis and editing model.", []),
-    
         "anthropic/claude-sonnet-4.5": ("Anthropic: Claude Sonnet 4.5.", []), 
-        "anthropic/claude-sonnet-4.6": ("Anthropic: Claude Sonnet 4.6.", []), 
         "anthropic/claude-opus-4.5": ("Anthropic: Claude Opus 4.5.", []), 
         "anthropic/claude-opus-4.6": ("Anthropic: Claude Opus 4.6.", []), 
         "anthropic/claude-opus-4.7": ("Anthropic: Claude Opus 4.7.", []), 
@@ -966,7 +964,6 @@ def _dialog_model_main(orchestrator, target="main"):
         "z-ai/glm-5": ("Z.ai: GLM 5.", []), 
         "z-ai/glm-5.2": ("Z.ai: GLM 5.2.", []), 
         "qwen/qwen3.7-plus": ("Qwen: Qwen3.7 Plus.", []), 
-        "qwen/qwen3.7-max": ("Qwen: Qwen3.7 Max.", []), 
         "qwen/qwen3.6-plus": ("Qwen: Qwen3.6 Plus.", []), 
         "openai/gpt-5.4-mini": ("OpenAI: GPT-5.4 Mini.", []), 
         "minimax/minimax-m2.5": ("MiniMax: MiniMax M2.5.", []), 
@@ -1334,6 +1331,8 @@ def _dialog_model_main(orchestrator, target="main"):
             display_id = "Krea 2 image"
         elif display_id == "gemini-3.1-pro-preview-customtools":
             display_id = "gemini-3.1-pro-preview"
+        elif "qwen3-next-80b" in display_id.lower() or "qwen3-next-80b" in mid.lower():
+            display_id = "Qwen3 Next 80B"
         else:
             display_id = display_id.replace('-', ' ')
             if display_id:
@@ -1348,6 +1347,11 @@ def _dialog_model_main(orchestrator, target="main"):
 
         desc = m.get("desc", "Fast, efficient model for daily tasks.")
 
+        # Determine explicit vision capability from models.txt / MODEL_REGISTRY
+        from utim_cli.tools import is_model_vision_capable
+        vis_tag = "[Vision: True]" if is_model_vision_capable(mid) else "[Vision: False]"
+        full_desc = f"{vis_tag} {desc}"
+
         style      = bg or ('fg:#f9e2af' if source == 'custom' else 'fg:#cdd6f4')
         desc_style = bg or 'fg:#585b70'
 
@@ -1374,7 +1378,7 @@ def _dialog_model_main(orchestrator, target="main"):
                     cost_style = "fg:#f38ba8"
 
             desc_width = max(24, min(54, (console.size.width or 100) - 62))
-            desc_lines = _compact_desc(desc, desc_width)
+            desc_lines = _compact_desc(full_desc, desc_width)
             desc_text = f" {desc_lines[0]}{current}\n"
             for extra in desc_lines[1:]:
                 desc_text += f"{'':<55}{extra}\n"
@@ -1388,7 +1392,7 @@ def _dialog_model_main(orchestrator, target="main"):
             ]
         else:
             desc_width = max(24, min(72, (console.size.width or 100) - 10))
-            desc_lines = _compact_desc(desc, desc_width)
+            desc_lines = _compact_desc(full_desc, desc_width)
             desc_text = "".join(f"     {line}\n" for line in desc_lines) + "\n"
             return [
                 (style,      f"  {display_id}"),

{utim_cli-2.0.1 → utim_cli-2.0.2}/utim_cli/utim.py

@@ -1196,7 +1196,7 @@ def _print_animated_banner(animated: bool = True):
     else:
         console.print(f"[bold {color}]{BANNER_BIG}[/bold {color}]")
             
-    console.print(f" [bold white]U Think I Make[/bold white] [bold #cba6f7]v2.0.1[/bold #cba6f7]")
+    console.print(f" [bold white]U Think I Make[/bold white] [bold #cba6f7]v2.0.2[/bold #cba6f7]")
     user_email = config.email
     is_logged_in = bool(config.token and user_email and user_email.upper() != "GUEST")
     user_type = "Guest Mode" if not is_logged_in else "UTIM Community"
@@ -2003,7 +2003,7 @@ def _run_mcp_search_list_dialog(rows, render_row_fn, title="", legend="", search
             return [
                 ('', '\n'),
                 ('bold #f38ba8', '    ⚠️  No matching MCP servers found.\n'),
-                ('dim', '    Try searching for different keywords (e.g. database, search, maps, slack).\n')
+                ('class:dim', '    Try searching for different keywords (e.g. database, search, maps, slack).\n')
             ]
 
         matching_heights = [row_heights[orig_idx] for orig_idx, _ in filtered_rows]
@@ -4686,7 +4686,7 @@ def check_and_update_background():
                 return
 
             latest_ver = resp.json().get("version", "")
-            current_ver = "2.0.1"
+            current_ver = "2.0.2"
 
             def parse_ver(v):
                 return [int(x) for x in v.split(".") if x.isdigit()]

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

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