utim-cli 2.5.1__tar.gz → 2.5.3__tar.gz

{utim_cli-2.5.1 → utim_cli-2.5.3}/CHANGELOG.md

@@ -1,11 +1,19 @@
 # Changelog
 
+## [2.5.3] - 2026-10-20
+
+### ✨ Improvements & Fixes
+- Stability, streaming, and rate-limit handling improvements.
+
+## [2.5.2] - 2026-10-18
+
+### 🐛 Fixes
+- **Paid Plan Model Gating & Aliases**: Fixed preflight model registry check in `completion_routes.py` so paid subscribers (Hobby/Pro/Max/Ultra) are never blocked by free-plan error notices.
+
 ## [2.5.1] - 2026-10-18
 
 ### 🐛 Fixes
 - **Compression Empty-Response Spam**: `_call_compression_model_with_fallback` now always sets `last_error` on empty/stripped content and logs `model=… routing=… empty_hits=…` diagnostics — eliminates the endless `[COMPRESSION FALLBACK FAILURE] Last error: None` loop and surfaces the real reason (429 / empty content / bad shape).
-- **Admin Portal CORS**: `router.py` now always allows `Origin: null` (downloaded `file://` HTML) and `allow_headers=["*"]` + `max_age=600` so `X-UTIM-Master-Key` / `Authorization` preflights for `/api/admin/*` and `/models` no longer fail with `No 'Access-Control-Allow-Origin'`.
-- **Admin Firewall Bypass**: `firewall.py: _FIREWALL_SKIP_PREFIXES` and `cli_auth.py: PUBLIC_PREFIXES` now include `/admin`, `/admin.html`, `/admin_models.html`, `/static` so the browser-served admin panel bypasses proxy-abuse / burst throttling and CLI HMAC `401` (API auth via master-key session is still enforced).
 
 ## [2.5.0] - 2026-10-18
 

{utim_cli-2.5.1/utim_cli.egg-info → utim_cli-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.5.1
+Version: 2.5.3
 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

{utim_cli-2.5.1 → utim_cli-2.5.3}/pyproject.toml

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

{utim_cli-2.5.1 → utim_cli-2.5.3}/utim/__init__.py

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

{utim_cli-2.5.1 → utim_cli-2.5.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.5.1"
+    __version__ = "2.5.3"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.5.1 → utim_cli-2.5.3}/utim_cli/_version.py

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

{utim_cli-2.5.1 → utim_cli-2.5.3}/utim_cli/architecture_indexer.py

@@ -140,66 +140,53 @@ def architecture_lock(project_path: str = ".") -> str:
     _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_file = _mem.get("arch_file")
         _cached_result = _mem.get("result")
-        if _cached_dir and Path(_cached_dir).exists() and _cached_result:
+        if _cached_file and Path(_cached_file).is_file() 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."
+                + f"\n\n⚠️ Do NOT call architecture_lock again this session. Read the file at: `{_cached_file}`"
             )
 
     # ── 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"
+    arch_file = arch_dir / "architecture.md"
     meta_file = arch_dir / ".arch_lock_meta.json"
 
-    # ── 3. Disk cache: reuse if the graph is fresh AND file tree unchanged ───
+    # ── 3. Disk cache: reuse if the single-file index is fresh AND file tree unchanged
     _tree_hash = _quick_file_tree_hash(abs_path)
     try:
-        if brain_file.exists() and meta_file.exists():
+        if arch_file.is_file() and brain_file.is_file() and meta_file.is_file():
             _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."
-                    )
+                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"
+                _arch_uri = f"file:///{str(arch_file.absolute()).replace(chr(92), '/')}"
+                _result = (
+                    f"✓ Architecture lock (CACHED — reused, not re-indexed)\n"
+                    f"Identified stack: {_ptype} | Indexed files: {_n_files} | Age: {int(_age)}s\n"
+                    f"Architecture file: `{arch_file}`\n"
+                    f"URI: {_arch_uri}\n\n"
+                    f"NEXT STEP: Read the architecture with `read_file(\"{arch_file}\")` "
+                    f"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_file": str(arch_file), "result": _result}
+                return (
+                    "[CACHED — architecture lock reused from disk; NOT re-indexed]\n"
+                    + _result
+                    + f"\n\n⚠️ Do NOT call architecture_lock again. Read the file at: `{arch_file}`"
+                )
     except Exception:
         pass  # any cache failure → fall through to full index
 
@@ -310,41 +297,84 @@ def architecture_lock(project_path: str = ".") -> str:
             md_block += f"```text\n{snippet}\n```\n"
             clusters[cluster_name].append(md_block)
 
-    # Dynamically generate markdown files based on organic clusters
-    generated_mds = []
-    for cname, blocks in clusters.items():
-        if not blocks: continue
-        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname)
-        md_content = f"# 🧩 Architecture Component: {cname.title()}\n\n" + "\n".join(blocks)
-        md_filename = f"component_{safe_cname}.md"
-        (arch_dir / md_filename).write_text(md_content, encoding="utf-8")
-        generated_mds.append(md_filename)
-
-    domain_links = ", ".join([
-        "[file:///{}]".format(str(arch_dir.absolute() / m).replace(chr(92), "/"))
-        for m in generated_mds
-    ])
-    conventions = [
-        "## Innate Project Architecture Rules",
-        "- **Organic Component Isolation**: The project is structured organically. Do not bloat central routers or core files.",
-        "- **Multifile Designs**: When adding large new features, ALWAYS create new standalone component files based on the existing directory structure.",
-        "- **MANDATORY ARCHITECTURE REVIEW**: You MUST use `read_file` on the relevant domain files below BEFORE exploring the source code manually. They contain the exact structural blueprints you need.",
-        "- **Available Domain Files**: " + domain_links
+    # ── Build single consolidated architecture.md (TOC + all clusters) ──────
+    # Remove stale split files from previous multi-file runs
+    for _stale in arch_dir.glob("component_*.md"):
+        try:
+            _stale.unlink()
+        except Exception:
+            pass
+    for _stale in (arch_dir / "conventions_summary.txt",):
+        try:
+            if _stale.is_file():
+                _stale.unlink()
+        except Exception:
+            pass
+
+    # Stable ordering for reproducible output
+    _ordered_clusters = sorted(clusters.items(), key=lambda kv: kv[0].lower())
+    # TOC entries — link to per-cluster anchors inside the single file
+    _toc_lines: List[str] = []
+    for cname, blocks in _ordered_clusters:
+        if not blocks:
+            continue
+        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname.lower())
+        anchor = f"component-{safe_cname}"
+        _toc_lines.append(f"- [{cname.title()}](#{anchor}) — {len(blocks)} symbol(s)/note(s)")
+
+    _header = [
+        f"# Project Architecture — `{Path(abs_path).name}`",
+        "",
+        f"- **Stack:** {', '.join(project_type) or 'Unknown'}",
+        f"- **Root:** `{abs_path}`",
+        f"- **Indexed files:** {len(inventory)}",
+        f"- **Generated:** {arch_file.name} (single consolidated file — all domains inline)",
+        "",
+        "## Table of Contents",
+        "- [Conventions](#conventions)",
+    ]
+    if _toc_lines:
+        _header.extend(_toc_lines)
+    _header.extend(["", "---", ""])
+
+    _conventions = [
+        "## Conventions",
+        "- **Component isolation**: Keep domains isolated. Do not bloat central routers.",
+        "- **Multifile expansion**: For large features, create new standalone files following existing directory structure.",
+        "- **Grounding**: This document is the zero-token structural ground truth. Prefer it over blind directory walks.",
+        "",
+        "---",
+        "",
     ]
-    (arch_dir / "conventions_summary.txt").write_text("\n".join(conventions), encoding="utf-8")
 
+    _body_parts: List[str] = _header + _conventions
+    for cname, blocks in _ordered_clusters:
+        if not blocks:
+            continue
+        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname.lower())
+        anchor = f"component-{safe_cname}"
+        _body_parts.append(f'<a id="{anchor}"></a>')
+        _body_parts.append(f"## 🧩 {cname.title()}")
+        _body_parts.append("")
+        _body_parts.extend(blocks)
+        _body_parts.append("")
+        _body_parts.append("---")
+        _body_parts.append("")
+
+    _arch_content = "\n".join(_body_parts).rstrip() + "\n"
+    arch_file.write_text(_arch_content, encoding="utf-8")
+
+    # ── Structural dependency graph (kept for tooling; not the LLM-facing artifact)
     unique_nodes = {n["id"]: n for n in nodes}.values()
-
     graph_data = {
         "project_path": abs_path,
         "project_type": project_type,
         "total_files": len(inventory),
         "nodes": list(unique_nodes),
         "edges": edges,
-        "capabilities": ["Project orientation", "Graph traversal", "Symbol resolution"]
+        "capabilities": ["Project orientation", "Graph traversal", "Symbol resolution"],
     }
-    
-    with open(brain_file, 'w', encoding='utf-8') as bf:
+    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)
@@ -353,24 +383,17 @@ def architecture_lock(project_path: str = ".") -> str:
     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"
-
+    _arch_uri = f"file:///{str(arch_file.absolute()).replace(chr(92), '/')}"
     _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"
-        f"1. Structural Dependency Graph: `00_architecture_map.json` (all file nodes, module imports, and symbol definitions)\n"
-        f"2. Architecture Conventions: `conventions_summary.txt`\n"
-        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.\n"
-        f"- Do NOT call architecture_lock again this session — reuse the blueprints above."
+        f"✓ Architecture lock successfully generated\n"
+        f"Identified stack: {', '.join(project_type) or 'Unknown'} | Indexed files: {len(inventory)}\n"
+        f"Architecture file: `{arch_file}`\n"
+        f"URI: {_arch_uri}\n\n"
+        f"This single file contains ALL domain sections inline (TOC + conventions + {len([b for _, b in _ordered_clusters if b])} component groups).\n"
+        f"NEXT STEP: Read it with `read_file(\"{arch_file}\")` to inspect exact function/class signatures and dependencies before editing source code.\n"
+        f"Do NOT call architecture_lock again this session — re-use this file."
     )
     # 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}
+    _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_file": str(arch_file), "result": _result_str}
     return _result_str
 

{utim_cli-2.5.1 → utim_cli-2.5.3}/utim_cli/client_utils.py

@@ -166,7 +166,7 @@ def get_server_model_catalog(timeout: float = 5.0) -> dict | None:
         )
         if resp.status_code == 200:
             data = resp.json()
-            if isinstance(data, dict) and data:
+            if isinstance(data, dict):
                 _catalog_cache = data
                 _catalog_cache_ts = now
                 return _catalog_cache
@@ -201,7 +201,7 @@ def fetch_remote_models_catalog(timeout: float = 3.0) -> dict:
         resp = requests.get(url, timeout=timeout)
         if resp.status_code == 200:
             models_list = resp.json()
-            if models_list and isinstance(models_list, list):
+            if isinstance(models_list, list):
                 from utim_cli.constants import APINEX_MODEL_IDS
                 valid_models = [
                     m for m in models_list
@@ -261,7 +261,7 @@ def fetch_remote_models_catalog(timeout: float = 3.0) -> dict:
         resp = requests.get(url, params=params, headers=get_auth_headers(), timeout=timeout)
         if resp.status_code == 200:
             data = resp.json()
-            if data and isinstance(data, dict):
+            if isinstance(data, dict):
                 from utim_cli.constants import APINEX_MODEL_IDS
                 filtered_cat = {
                     k: [
@@ -281,7 +281,7 @@ def fetch_remote_models_catalog(timeout: float = 3.0) -> dict:
     try:
         from utim_cli.server.models import get_model_catalog
         data = get_model_catalog()
-        if data:
+        if isinstance(data, dict):
             _REMOTE_CATALOG_CACHE = data
             _REMOTE_CATALOG_CACHE_TIME = now
             return data
@@ -312,7 +312,7 @@ def _build_free_models_fallback_chain(now: float) -> list[str]:
         resp = _req.get(f"{SERVER_URL.rstrip('/')}/models", timeout=3.0)
         if resp.status_code == 200:
             models_list = resp.json()
-            if models_list and isinstance(models_list, list):
+            if isinstance(models_list, list):
                 from utim_cli.constants import APINEX_MODEL_IDS
                 for m in models_list:
                     mid = str(m.get("model_id") or "")
@@ -407,6 +407,86 @@ def resolve_model_provider_endpoint(model_id: Optional[str]) -> Optional[Dict[st
     except Exception:
         pass
 
+    # 1b. Server ModelEndpointDB and Separated Models (configured via admin_models.html)
+    try:
+        from utim_cli.server.db import SessionLocal, ModelEndpointDB, SEPARATED_MODEL_CLASSES
+        sdb = SessionLocal()
+        try:
+            cand_ids = {clean_id, clean_id.lower()}
+            stripped = clean_id
+            for pref in ("am/", "api/", "ag/"):
+                if clean_id.startswith(pref):
+                    stripped = clean_id[len(pref):].strip()
+                    break
+            cand_ids.add(stripped)
+            cand_ids.add(stripped.lower())
+            for pref in ("am/", "api/", "ag/"):
+                cand_ids.add(f"{pref}{stripped}")
+                cand_ids.add(f"{pref}{stripped}".lower())
+            if "/" in stripped:
+                base_part = stripped.split("/")[-1].strip()
+                cand_ids.add(base_part)
+                cand_ids.add(base_part.lower())
+                for pref in ("am/", "api/", "ag/"):
+                    cand_ids.add(f"{pref}{base_part}")
+                    cand_ids.add(f"{pref}{base_part}".lower())
+            if "/" in clean_id:
+                base_raw = clean_id.split("/")[-1].strip()
+                cand_ids.add(base_raw)
+                cand_ids.add(base_raw.lower())
+                for pref in ("am/", "api/", "ag/"):
+                    cand_ids.add(f"{pref}{base_raw}")
+                    cand_ids.add(f"{pref}{base_raw}".lower())
+
+            ep = sdb.query(ModelEndpointDB).filter(
+                ModelEndpointDB.model_id.in_(cand_ids),
+                (ModelEndpointDB.is_active == True) | (ModelEndpointDB.is_active.is_(None)),
+                ModelEndpointDB.endpoint_url.isnot(None),
+                ModelEndpointDB.endpoint_url != ""
+            ).order_by(ModelEndpointDB.priority.asc()).first()
+            if ep and ep.endpoint_url:
+                base = ep.endpoint_url.rstrip("/")
+                url = base if base.endswith("/chat/completions") else f"{base}/chat/completions"
+                keys = ep.get_api_keys()
+                key = keys[0] if keys else ""
+                raw_up = (getattr(ep, "upstream_model_id", None) or "").strip()
+                target_m = raw_up if raw_up else (ep.model_id or clean_id)
+                return {
+                    "url": url,
+                    "base_url": base,
+                    "api_key": key,
+                    "auth_style": "bearer",
+                    "target_model": target_m,
+                    "provider_name": ep.provider_id or "custom",
+                }
+
+            for s_cls in SEPARATED_MODEL_CLASSES:
+                m_row = sdb.query(s_cls).filter(
+                    s_cls.model_id.in_(cand_ids),
+                    (s_cls.is_active == True) | (s_cls.is_active.is_(None)),
+                    s_cls.endpoint_url.isnot(None),
+                    s_cls.endpoint_url != ""
+                ).first()
+                if m_row and getattr(m_row, "endpoint_url", None):
+                    base = m_row.endpoint_url.rstrip("/")
+                    url = base if base.endswith("/chat/completions") else f"{base}/chat/completions"
+                    keys = m_row.get_api_keys() if hasattr(m_row, "get_api_keys") else []
+                    key = keys[0] if keys else ""
+                    raw_up = (getattr(m_row, "upstream_model_id", None) or "").strip()
+                    target_m = raw_up if raw_up else (m_row.model_id or clean_id)
+                    return {
+                        "url": url,
+                        "base_url": base,
+                        "api_key": key,
+                        "auth_style": "bearer",
+                        "target_model": target_m,
+                        "provider_name": getattr(m_row, "provider", "custom") or "custom",
+                    }
+        finally:
+            sdb.close()
+    except Exception:
+        pass
+
     # 2. Server ApiModel database (upstream provider attached in admin_models.html)
     try:
         from utim_cli.server.api_models_db import ApiSessionLocal, ApiModel, find_canonical_model
@@ -902,12 +982,15 @@ def sanitize_tools_for_api(tools: Optional[List[Dict[str, Any]]], model_id: Opti
             if k in disallowed_keys:
                 continue
 
-            # Standardize JSON schema type names to lowercase
+            _valid = {"string", "number", "integer", "boolean", "array", "object", "null"}
             if k == "type":
                 if isinstance(v, str):
-                    v = TYPE_MAP.get(v, v.lower())
+                    _t = TYPE_MAP.get(v, v.lower())
+                    v = _t if _t in _valid else "string"
                 elif isinstance(v, list):
-                    v = [TYPE_MAP.get(item, item.lower()) if isinstance(item, str) else item for item in v]
+                    _lst = [TYPE_MAP.get(item, item.lower()) if isinstance(item, str) else item for item in v]
+                    _lst = [x for x in _lst if x in _valid]
+                    v = _lst[0] if len(_lst)==1 else (_lst if _lst else "string")
 
             if isinstance(v, dict):
                 cleaned[k] = _clean_schema_node(v)