utim-cli 2.4.2__tar.gz → 2.5.0__tar.gz

{utim_cli-2.4.2 → utim_cli-2.5.0}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [2.5.0] - 2026-10-18
+
+### ✨ Credit System → Unlimited UX + Internal Throttling
+- **Paid = Unlimited Tokens (Rate-Limits Apply)**: All paid plans now display Unlimited Tokens; caps are enforced server-side as 5-hour refill + weekly fair-use throttling + Quota Bank rollover (never a hard credit wall).
+- **Pricing & Docs Alignment**: Synced landing, docs, and prerender copy — Free stays 3,000 tokens/month.
+
+### 🐛 Fixes
+- **Keyring Startup Spam**: Deduped OS-keyring warning to once-per-process and demoted to `debug` so adding 4 BYOK models no longer floods the terminal.
+- **Firewall & Compression Hardening**: External firewall suites remain isolated; BYOK/custom compression routing fixed.
+
+### 🔧 Internal
+- **BYOK / Custom Provider Compression**: `_resolve_compression_routing` now mirrors live `Orchestrator.model_source` so summarize/compress requests follow the same provider as the main model.
+
+## [2.4.3] - 2026-10-13
+
+### 🛡️ Process Immunity & Self-Kill Protection
+- **Immunity Against Self-Termination**: Protected the UTIM process tree from accidental termination when executing shell commands like `taskkill`, `kill`, or `Stop-Process`. Resolves ancestry PIDs and blocks commands targeting own PID or executable names.
+
+### 🐛 Model Response & Streaming Fixes
+- **Claude / Anthropic Completion Stability**: Fixed an issue where blank finish reasons on clean streaming completions defaulted to `"length"`, triggering spurious truncation warnings.
+- **Removed Active-Turn `[status: pending]` Tagging**: Removed active user message status injection that previously confused models (especially Claude) into premature halts or continuation loops.
+- **Backtick Heuristic Gating**: Gated unclosed code-block detection to only fire on non-clean completions, preventing false truncation triggers on prose responses.
+
 ## [2.4.2] - 2026-10-13
 
 ### 🤖 Sub-Agent Swarm Model Configuration & Hardcoded Lock

{utim_cli-2.4.2/utim_cli.egg-info → utim_cli-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.4.2
+Version: 2.5.0
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev
@@ -20,12 +20,12 @@ Classifier: Intended Audience :: Developers
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests==2.31.0
+Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.9.5
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: python-dotenv==1.0.1
-Requires-Dist: urllib3==1.26.18
-Requires-Dist: charset-normalizer==3.3.2
+Requires-Dist: urllib3>=2.2.3
+Requires-Dist: charset-normalizer>=3.3.2
 Requires-Dist: chardet==4.0.0
 Requires-Dist: typer>=0.9.0
 Requires-Dist: rich>=13.0.0

{utim_cli-2.4.2 → utim_cli-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.4.2"
+version = "2.5.0"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
@@ -23,12 +23,12 @@ classifiers = [
     "Intended Audience :: Developers",
 ]
 dependencies = [
-    "requests==2.31.0",
+    "requests>=2.32.3",
     "aiohttp>=3.9.5",
     "httpx>=0.25.0",
     "python-dotenv==1.0.1",
-    "urllib3==1.26.18",
-    "charset-normalizer==3.3.2",
+    "urllib3>=2.2.3",
+    "charset-normalizer>=3.3.2",
     "chardet==4.0.0",
     "typer>=0.9.0",
     "rich>=13.0.0",

{utim_cli-2.4.2 → utim_cli-2.5.0}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.4.2"
+    __version__ = "2.5.0"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.4.2 → utim_cli-2.5.0}/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.4.2"
+    __version__ = "2.5.0"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.4.2 → utim_cli-2.5.0}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.4.2"
+VERSION = "2.5.0"
 
 

{utim_cli-2.4.2 → utim_cli-2.5.0}/utim_cli/architecture_indexer.py

@@ -93,18 +93,115 @@ def index_generic_file(filepath: Path) -> dict:
     except Exception:
         return {"imports": [], "symbols": []}
 
+# ── Session-level in-memory cache: prevents re-indexing within the same process ──
+_ARCH_LOCK_MEM_CACHE: dict = {}
+# Reuse window: if the same project is locked again within this TTL, return the
+# cached result instantly at zero cost. 600 s = 10 min covers an entire session.
+_ARCH_LOCK_COOLDOWN_S = 600
+# Disk cache TTL for the stable arch_lock dir — if the graph file is fresher than
+# this, the project file tree is considered unchanged unless force-refreshed.
+_ARCH_LOCK_DISK_TTL_S = 600
+
+
+def _quick_file_tree_hash(project_path: str) -> str:
+    """Cheap hash of the project's file listing (names + mtimes) for change detection."""
+    import time as _t
+    h = hashlib.sha256()
+    try:
+        for root, dirs, files in os.walk(project_path):
+            # mirror _ignore_dir filtering so hash is stable
+            dirs[:] = [d for d in dirs if not _ignore_dir(d)]
+            for f in sorted(files):
+                if f.startswith('.'):
+                    continue
+                fp = os.path.join(root, f)
+                try:
+                    st = os.stat(fp)
+                    h.update(f.encode())
+                    h.update(str(int(st.st_mtime)).encode())
+                    h.update(str(st.st_size).encode())
+                except Exception:
+                    h.update(f.encode())
+    except Exception:
+        pass
+    return h.hexdigest()[:16]
+
+
 def architecture_lock(project_path: str = ".") -> str:
-    import uuid
+    import time as _time
     from utim_cli.brain import get_current_resolved_project
     abs_path = os.path.abspath(project_path)
     if not os.path.isdir(abs_path):
         return f"Error: Project path '{abs_path}' does not exist or is not a directory."
 
     proj_id, proj_dir = get_current_resolved_project(abs_path)
-    arch_hash = uuid.uuid4().hex[:8]
-    arch_dir = proj_dir / f"arch_{arch_hash}"
+
+    # ── 1. In-memory session cache (zero-IO fast path) ───────────────────────
+    _now = _time.time()
+    _mem = _ARCH_LOCK_MEM_CACHE.get(proj_id)
+    if _mem and (_now - _mem.get("ts", 0) < _ARCH_LOCK_COOLDOWN_S):
+        _cached_dir = _mem.get("arch_dir")
+        _cached_result = _mem.get("result")
+        if _cached_dir and Path(_cached_dir).exists() and _cached_result:
+            # Fresh within the session — return cached output instantly.
+            return (
+                "[CACHED — architecture lock already generated this session; NOT re-indexed]\n"
+                + _cached_result
+                + "\n\n⚠️ Do NOT call architecture_lock again this session. "
+                  "Use `read_file` on the component_<domain>.md blueprints listed above."
+            )
+
+    # ── 2. Stable single directory (replaces per-call arch_{uuid} spam) ───────
+    arch_dir = proj_dir / "arch_lock"
     arch_dir.mkdir(parents=True, exist_ok=True)
     brain_file = arch_dir / "00_architecture_map.json"
+    meta_file = arch_dir / ".arch_lock_meta.json"
+
+    # ── 3. Disk cache: reuse if the graph is fresh AND file tree unchanged ───
+    _tree_hash = _quick_file_tree_hash(abs_path)
+    try:
+        if brain_file.exists() and meta_file.exists():
+            _meta = json.loads(meta_file.read_text(encoding="utf-8"))
+            _age = _now - float(_meta.get("ts", 0))
+            _same_tree = _meta.get("tree_hash") == _tree_hash
+            if _same_tree and _age < _ARCH_LOCK_DISK_TTL_S:
+                # Rebuild the lightweight return string from the cached dir
+                # without re-walking / re-parsing the entire codebase.
+                _cached_mds = sorted([p.name for p in arch_dir.glob("component_*.md")])
+                if _cached_mds:
+                    # Count files from cached graph
+                    try:
+                        _g = json.loads(brain_file.read_text(encoding="utf-8"))
+                        _n_files = _g.get("total_files", "?")
+                        _ptype = ", ".join(_g.get("project_type", [])) or "Unknown"
+                    except Exception:
+                        _n_files, _ptype = "?", "Unknown"
+                    _bullets = "\n".join(
+                        f"- {m}: [file:///{str((arch_dir / m).absolute()).replace(chr(92), '/')}]"
+                        for m in _cached_mds
+                    )
+                    _result = (
+                        f"✓ Architecture lock (CACHED — reused, not re-indexed) at: {arch_dir}\n"
+                        f"Identified stack: {_ptype} | Indexed files: {_n_files} | Age: {int(_age)}s\n\n"
+                        f"WHAT WAS PROVIDED:\n"
+                        f"1. Structural Dependency Graph: `00_architecture_map.json`\n"
+                        f"2. Architecture Conventions: `conventions_summary.txt`\n"
+                        f"3. Modular Component Blueprints ({len(_cached_mds)} domain modules):\n{_bullets}\n\n"
+                        f"WHY THIS IS NEEDED & NEXT ACTION:\n"
+                        f"- Zero-token structural grounding eliminates hallucinations and token-wasting blind exploration.\n"
+                        f"- NEXT STEP: Use `read_file` on the relevant `component_<domain>.md` blueprint above "
+                        f"matching your task to inspect exact function/class signatures BEFORE editing.\n"
+                        f"- Do NOT call architecture_lock again unless the project file tree has changed."
+                    )
+                    _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_dir": str(arch_dir), "result": _result}
+                    return (
+                        "[CACHED — architecture lock reused from disk; NOT re-indexed]\n"
+                        + _result
+                        + "\n\n⚠️ Do NOT call architecture_lock again. "
+                          "Use `read_file` on the component blueprints listed above."
+                    )
+    except Exception:
+        pass  # any cache failure → fall through to full index
 
     inventory = []
     project_type = []
@@ -250,12 +347,18 @@ def architecture_lock(project_path: str = ".") -> str:
     with open(brain_file, 'w', encoding='utf-8') as bf:
         json.dump(graph_data, bf, indent=2)
 
+    # Write meta sidecar for disk-cache invalidation (tree hash + timestamp)
+    try:
+        meta_file.write_text(json.dumps({"ts": _now, "tree_hash": _tree_hash}, indent=2), encoding="utf-8")
+    except Exception:
+        pass
+
     component_bullets = "\n".join([
         f"- {m}: [file:///{str(arch_dir.absolute() / m).replace(chr(92), '/')}]"
         for m in generated_mds
     ]) if generated_mds else "- None"
 
-    return (
+    _result_str = (
         f"✓ Architecture lock successfully generated at: {arch_dir}\n"
         f"Identified stack: {', '.join(project_type) or 'Unknown'} | Indexed files: {len(inventory)}\n\n"
         f"WHAT WAS PROVIDED:\n"
@@ -264,6 +367,10 @@ def architecture_lock(project_path: str = ".") -> str:
         f"3. Modular Component Blueprints ({len(generated_mds)} domain modules):\n{component_bullets}\n\n"
         f"WHY THIS IS NEEDED & NEXT ACTION:\n"
         f"- Zero-token structural grounding eliminates hallucinations and token-wasting blind repo exploration.\n"
-        f"- NEXT STEP: Use `read_file` on the relevant `component_<domain>.md` blueprint above matching your task to inspect exact function/class signatures and dependencies before reading or editing source code."
+        f"- NEXT STEP: Use `read_file` on the relevant `component_<domain>.md` blueprint above matching your task to inspect exact function/class signatures and dependencies before reading or editing source code.\n"
+        f"- Do NOT call architecture_lock again this session — reuse the blueprints above."
     )
+    # Populate in-memory cache so a second call this session is instant
+    _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_dir": str(arch_dir), "result": _result_str}
+    return _result_str
 

{utim_cli-2.4.2 → utim_cli-2.5.0}/utim_cli/ask_helper.py

@@ -24,14 +24,15 @@ from rich.text import Text
 from rich.markdown import Markdown
 from rich import box
 
-# ── Primary & Fallback Free Models ───────────────────────────────────────────
+# ── Sidecar Helper Model ───────────────────────────────────────────
 
-from utim_cli.client_utils import get_free_models_fallback_chain
+PRIMARY_HELPER_MODEL = "nvidia/nemotron-3.5-lightning:free"
+
+
+def get_free_models_fallback_chain() -> List[str]:
+    """Return single primary helper model (fallback chain disabled)."""
+    return [PRIMARY_HELPER_MODEL]
 
-# Primary helper model = 'nvidia/nemotron-3.5-lightning:free' (verified free model), then falls
-# back through the verified free models from the server DB registry.
-_HELPER_FALLBACK_CHAIN = get_free_models_fallback_chain()
-PRIMARY_HELPER_MODEL = _HELPER_FALLBACK_CHAIN[0] if _HELPER_FALLBACK_CHAIN else "nvidia/nemotron-3.5-lightning:free"
 
 
 
@@ -339,7 +340,7 @@ def execute_ask_helper(
     if not console:
         console = Console(highlight=False, markup=True)
 
-    models_to_try = get_free_models_fallback_chain()
+    model = PRIMARY_HELPER_MODEL
     
     # Pre-extract live session chat history and context
     chat_summary = read_chat_history(orchestrator, max_turns=12)
@@ -378,95 +379,89 @@ def execute_ask_helper(
         call_success = False
         last_error = ""
 
-        for model in models_to_try:
-            try:
-                from utim_cli.client_utils import proxy_openrouter_request
-                resp = proxy_openrouter_request(
-                    json_data={
-                        "model": model,
-                        "messages": messages,
-                        "tools": tools,
-                        "max_tokens": 1000,
-                    },
-                    stream=False,
-                    timeout=(15, 300),
-                    is_reflection=False,
-                )
-                if resp.status_code == 429:
-                    continue
-                resp.raise_for_status()
-
-                data = resp.json()
-                choice = data.get("choices", [{}])[0]
-                msg = choice.get("message", {})
-                content = msg.get("content") or ""
-                tool_calls = msg.get("tool_calls") or []
-
-                # Clean thinking tags
-                content = re.sub(r"<think(?:ing)?>.*?</think(?:ing)?>", "", content, flags=re.DOTALL).strip()
-
-                if tool_calls:
-                    messages.append({
-                        "role": "assistant",
-                        "content": content,
-                        "tool_calls": tool_calls,
-                    })
-
-                    for tc in tool_calls:
-                        fn = tc.get("function", {})
-                        fname = fn.get("name", "")
-                        call_id = tc.get("id", "call_tool")
-
-                        if fname == "read_chat":
-                            args_str = fn.get("arguments", "{}")
-                            try:
-                                args = json.loads(args_str) if isinstance(args_str, str) else args_str
-                            except Exception:
-                                args = {}
-                            max_turns = args.get("max_turns", 15)
-                            chat_result = read_chat_history(orchestrator, max_turns=max_turns)
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": call_id,
-                                "name": "read_chat",
-                                "content": chat_result,
-                            })
-                        elif fname in ("web_search", "websearch", "search"):
-                            args_str = fn.get("arguments", "{}")
-                            try:
-                                args = json.loads(args_str) if isinstance(args_str, str) else args_str
-                            except Exception:
-                                args = {}
-                            search_q = args.get("query") or args.get("prompt") or args.get("q") or question
-                            search_res = execute_sidecar_websearch(search_q)
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": call_id,
-                                "name": fname,
-                                "content": search_res[:12000],
-                            })
-                        else:
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": call_id,
-                                "name": fname,
-                                "content": f"Error: Tool '{fname}' is not allowed. Only 'read_chat' and 'web_search' are available.",
-                            })
-                    call_success = True
-                    break
-
-                elif content:
-                    final_response = content
-                    call_success = True
-                    break
-
-            except Exception as e:
-                last_error = str(e)
-                continue
+        try:
+            from utim_cli.client_utils import proxy_openrouter_request
+            resp = proxy_openrouter_request(
+                json_data={
+                    "model": model,
+                    "messages": messages,
+                    "tools": tools,
+                    "max_tokens": 1000,
+                },
+                stream=False,
+                timeout=(15, 300),
+                is_reflection=False,
+            )
+            resp.raise_for_status()
+
+            data = resp.json()
+            choice = data.get("choices", [{}])[0]
+            msg = choice.get("message", {})
+            content = msg.get("content") or ""
+            tool_calls = msg.get("tool_calls") or []
+
+            # Clean thinking tags
+            content = re.sub(r"<think(?:ing)?>.*?</think(?:ing)?>", "", content, flags=re.DOTALL).strip()
+
+            if tool_calls:
+                messages.append({
+                    "role": "assistant",
+                    "content": content,
+                    "tool_calls": tool_calls,
+                })
+
+                for tc in tool_calls:
+                    fn = tc.get("function", {})
+                    fname = fn.get("name", "")
+                    call_id = tc.get("id", "call_tool")
+
+                    if fname == "read_chat":
+                        args_str = fn.get("arguments", "{}")
+                        try:
+                            args = json.loads(args_str) if isinstance(args_str, str) else args_str
+                        except Exception:
+                            args = {}
+                        max_turns = args.get("max_turns", 15)
+                        chat_result = read_chat_history(orchestrator, max_turns=max_turns)
+                        messages.append({
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "name": "read_chat",
+                            "content": chat_result,
+                        })
+                    elif fname in ("web_search", "websearch", "search"):
+                        args_str = fn.get("arguments", "{}")
+                        try:
+                            args = json.loads(args_str) if isinstance(args_str, str) else args_str
+                        except Exception:
+                            args = {}
+                        search_q = args.get("query") or args.get("prompt") or args.get("q") or question
+                        search_res = execute_sidecar_websearch(search_q)
+                        messages.append({
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "name": fname,
+                            "content": search_res[:12000],
+                        })
+                    else:
+                        messages.append({
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "name": fname,
+                            "content": f"Error: Tool '{fname}' is not allowed. Only 'read_chat' and 'web_search' are available.",
+                        })
+                call_success = True
+
+            elif content:
+                final_response = content
+                call_success = True
+
+        except Exception as e:
+            last_error = str(e)
 
         if not call_success:
             if not final_response:
-                final_response = f"I'm here to help, but encountered connection errors across free fallback models: {last_error}"
+                final_response = f"I'm here to help, but encountered connection errors with model '{model}': {last_error}"
             break
 
         if final_response:

{utim_cli-2.4.2 → utim_cli-2.5.0}/utim_cli/blender_agent.py

@@ -54,42 +54,32 @@ from utim_cli.constants import DEFAULT_MODEL
 
 _OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
 
-_VISION_MODELS: List[str] = [
-    "google/gemma-4-31b-it:free",
-    "google/gemma-4-26b-a4b-it:free",
-    "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
-    "nvidia/nemotron-nano-12b-v2-vl:free",
-]
-
-from utim_cli.client_utils import get_free_models_fallback_chain
-
-_CODE_MODELS: List[str] = get_free_models_fallback_chain()
-
-
+_VISION_MODEL: str = "google/gemma-4-31b-it:free"
+_CODE_MODEL: str = "nvidia/nemotron-3.5-lightning:free"
 
 
 def _get_vision_models() -> List[str]:
-    """Return vision model list, with user override prepended if configured."""
+    """Return vision model (single model, no fallbacks)."""
     try:
         from utim_cli.config import config
         override = config.get("subagent_model_blender_vision")
         if override and override not in ("__non_agent__", "__none__"):
-            return [override] + [m for m in _VISION_MODELS if m != override]
+            return [override]
     except Exception:
         pass
-    return _VISION_MODELS
+    return [_VISION_MODEL]
 
 
 def _get_code_models() -> List[str]:
-    """Return code model list, with user override prepended if configured."""
+    """Return code model (single model, no fallbacks)."""
     try:
         from utim_cli.config import config
         override = config.get("subagent_model_blender_code")
         if override and override not in ("__non_agent__", "__none__"):
-            return [override] + [m for m in _CODE_MODELS if m != override]
+            return [override]
     except Exception:
         pass
-    return _CODE_MODELS
+    return [_CODE_MODEL]
 
 MAX_RETRIES = 3  # Script fix-and-retry attempts
 
@@ -552,36 +542,36 @@ def _llm_call(
     else:
         user_content = user_text
 
-    last_err: Exception = RuntimeError("No models tried.")
-    for model in models:
-        for attempt in range(3):
-            try:
-                from utim_cli.client_utils import proxy_openrouter_request
-                resp = proxy_openrouter_request(
-                    json_data={
-                        "model": model,
-                        "messages": [
-                            {"role": "system", "content": system},
-                            {"role": "user", "content": user_content},
-                        ],
-                        "max_tokens": max_tokens,
-                        "stream": False,
-                    },
-                    stream=False,
-                    timeout=timeout,
-                )
-                resp.raise_for_status()
-                data = resp.json()
-                text = data["choices"][0]["message"]["content"]
-                return text.strip()
-            except Exception as exc:  # noqa: BLE001
-                last_err = exc
-                code = getattr(getattr(exc, "response", None), "status_code", 0)
-                if code == 429 and attempt < 2:
-                    time.sleep(5 * (attempt + 1))
-                    continue
-                break  # try next model
-    raise RuntimeError(f"All LLM models failed. Last error: {last_err}") from last_err
+    last_err: Exception = RuntimeError("No model specified.")
+    model = models[0] if models else _CODE_MODEL
+    for attempt in range(3):
+        try:
+            from utim_cli.client_utils import proxy_openrouter_request
+            resp = proxy_openrouter_request(
+                json_data={
+                    "model": model,
+                    "messages": [
+                        {"role": "system", "content": system},
+                        {"role": "user", "content": user_content},
+                    ],
+                    "max_tokens": max_tokens,
+                    "stream": False,
+                },
+                stream=False,
+                timeout=timeout,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            text = data["choices"][0]["message"]["content"]
+            return text.strip()
+        except Exception as exc:  # noqa: BLE001
+            last_err = exc
+            code = getattr(getattr(exc, "response", None), "status_code", 0)
+            if code == 429 and attempt < 2:
+                time.sleep(5 * (attempt + 1))
+                continue
+            break
+    raise RuntimeError(f"LLM model '{model}' failed: {last_err}") from last_err
 
 
 # ---------------------------------------------------------------------------