utim-cli 2.3.17__tar.gz → 2.3.19__tar.gz

{utim_cli-2.3.17 → utim_cli-2.3.19}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [2.3.19] - 2026-09-02
+
+### 🛠️ Model Dialog Tier Sync & Free Model Preservation
+- Synchronized user plan resolution on account switch to prevent paid models leaking on free accounts
+- Fixed free models disappearing when bonus quota is active
+- Removed default selected model on fresh startup and added configuration prompts
+
+## [2.3.18] - 2026-09-02
+
+### 🎁 New Free Models Added & Tool Sanitization Fixes
+- Added new free models with key rotation
+- Fixed Google Gemini tool schema sanitization to prevent 400 Bad Request errors
+
 ## [2.3.17] - 2026-08-31
 
 ### ✨ Premium Model Visibility for Bonus-Credit Users

{utim_cli-2.3.17/utim_cli.egg-info → utim_cli-2.3.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.17
+Version: 2.3.19
 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.3.17 → utim_cli-2.3.19}/pyproject.toml

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

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim/__init__.py

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

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

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim_cli/_version.py

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

utim_cli-2.3.19/utim_cli/_wizard_smoke_test.py

@@ -0,0 +1,93 @@
+"""Smoke test for the new plugin scaffold wizard.
+
+Simulates a user filling out the wizard end-to-end and verifies that the
+generated plugin directory + plugin.json contain the basic fields.
+"""
+import os, sys, json, shutil, tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+# Set up an isolated UTIM home before importing the dialog
+TEST_HOME = Path(tempfile.mkdtemp(prefix="utim_wiz_test_"))
+os.environ["UTIM_HOME"] = str(TEST_HOME)
+os.environ["XDG_CONFIG_HOME"] = str(TEST_HOME)
+os.environ["XDG_DATA_HOME"] = str(TEST_HOME)
+
+sys.path.insert(0, ".")
+from utim_cli.plugins.manager import PluginManager
+from utim_cli.tui.plugins_dialog import _run_plugin_scaffold_wizard
+
+mgr = PluginManager()
+# Redirect workspace plugins dir via monkey-patch (property is read-only)
+import utim_cli.plugins.manager as mgr_mod
+real_prop = mgr_mod.PluginManager.workspace_plugins_dir
+fake_workspace_plugins = TEST_HOME / "plugins"
+fake_workspace_plugins.mkdir(parents=True, exist_ok=True)
+def _fake_workspace_dir(self):
+    return fake_workspace_plugins
+mgr_mod.PluginManager.workspace_plugins_dir = property(_fake_workspace_dir)
+
+# Sequence of inputs the user will type — matches the current 3-step wizard:
+#   Step 1: Plugin name
+#   Step 2: Description
+#   Step 3: Choice (1-4), scope (y/n), confirm (y/n), enable (y/n)
+inputs = iter([
+    # Step 1 — Plugin name
+    "my-cloud-tools",
+    # Step 2 — Description
+    "Awesome cloud dev tools",
+    # Step 3 — Choice 1 (Skill module)
+    "1",
+    # Scope: workspace (n = not global)
+    "n",
+    # Generate now?
+    "y",
+    # Enable now?
+    "y",
+])
+
+# Use prompt_toolkit's print_formatted_text + fake_prompter via pt_prompt monkeypatch
+from prompt_toolkit import prompt as pt_prompt
+original = pt_prompt
+def fake_prompt(message="", **kw):
+    try:
+        v = next(inputs)
+    except StopIteration:
+        raise EOFError
+    return v
+
+# Patch the import inside the dialog module
+import utim_cli.tui.plugins_dialog as pd
+with patch.object(pd, "pt_prompt", side_effect=fake_prompt):
+    # Also patch the bare `from prompt_toolkit import prompt` reference if any
+    try:
+        pd._run_plugin_scaffold_wizard(mgr)
+    except (StopIteration, EOFError):
+        print("WIZARD: ran out of input (likely fine if it finished early)")
+
+# Verify the generated plugin
+plugin_dir = mgr.workspace_plugins_dir / "my-cloud-tools"
+print("=" * 60)
+print(f"Plugin dir exists: {plugin_dir.exists()}")
+if plugin_dir.exists():
+    print("Files:")
+    for p in sorted(plugin_dir.rglob("*")):
+        if p.is_file():
+            print(f"  {p.relative_to(plugin_dir)}")
+    print("=" * 60)
+    manifest = json.loads((plugin_dir / "plugin.json").read_text(encoding="utf-8"))
+    print("plugin.json manifest:")
+    print(json.dumps(manifest, indent=2))
+    print("=" * 60)
+
+    # Assertions
+    assert manifest["name"] == "my-cloud-tools"
+    assert manifest["description"] == "Awesome cloud dev tools"
+    assert manifest["author"] == "Developer"
+    assert manifest["license"] == "MIT"
+    assert len(manifest["skills"]) == 1
+    assert manifest["skills"][0] == "skills/my-cloud-tools-workflow/SKILL.md"
+    print("✅ ALL ASSERTIONS PASSED")
+else:
+    print("❌ Plugin directory was not created")
+    sys.exit(1)

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim_cli/auth.py

@@ -495,8 +495,20 @@ def login(restart: bool = False) -> None:
             config.set("token", "device_flow")
             config.set("email", body.get("email", ""))
             config.set("uid", body.get("user_id", ""))
-            config.set("firebase_uid", body.get("firebase_uid", ""))
             config.set("name", body.get("display_name") or (body.get("email", "") or "").split("@")[0])
+            plan_name = body.get("plan")
+            if not plan_name and body.get("api_key"):
+                try:
+                    _vr = requests.get(
+                        f"{SERVER_URL}/api/user-plan",
+                        headers={"X-API-Key": body["api_key"]},
+                        timeout=3.0,
+                    )
+                    if _vr.status_code == 200:
+                        plan_name = (_vr.json() or {}).get("plan")
+                except Exception:
+                    pass
+            config.set("user_plan", (plan_name or "free").lower())
             if body.get("api_key"):
                 config.set("api_key", body["api_key"])
             raw_print("")

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim_cli/bootstrap.py

@@ -292,9 +292,54 @@ def scan_available_skills(force_reload: bool = False):
     try:
         from utim_cli.plugins.manager import get_plugin_manager
         p_mgr = get_plugin_manager()
-        for p_skill_name, p_skill_data in p_mgr.get_active_skills().items():
-            if p_skill_name not in skills and p_skill_name not in disabled:
-                skills[p_skill_name] = p_skill_data
+        active_skills_dict = p_mgr.get_active_skills()
+        p_items = active_skills_dict.items() if isinstance(active_skills_dict, dict) else [(s.get("name", s.get("raw_name")), s) for s in active_skills_dict]
+        for p_skill_name, p_skill_data in p_items:
+            if p_skill_name not in disabled:
+                s_path = p_skill_data.get("path")
+                s_content = p_skill_data.get("content", "")
+                s_desc = p_skill_data.get("description", "")
+                s_raw_name = p_skill_data.get("raw_name", p_skill_name)
+
+                if not s_desc and s_content and s_content.startswith("---"):
+                    parts = s_content.split("---", 2)
+                    if len(parts) >= 3:
+                        dm = re.search(r"^description:\s*(.+)$", parts[1], re.MULTILINE)
+                        if dm:
+                            s_desc = dm.group(1).strip().strip("\"'")
+
+                words = set()
+                for word in p_skill_name.replace('-', ' ').replace('_', ' ').replace(':', ' ').split():
+                    if len(word) > 2:
+                        words.add(word.lower())
+                for word in s_raw_name.replace('-', ' ').replace('_', ' ').split():
+                    if len(word) > 2:
+                        words.add(word.lower())
+                for word in s_desc.replace(',', ' ').replace('.', ' ').replace('(', ' ').replace(')', ' ').split():
+                    w = word.lower().strip()
+                    if len(w) > 2 and w not in stop_words:
+                        words.add(w)
+
+                size_bytes = 0
+                try:
+                    if hasattr(s_path, "stat"):
+                        size_bytes = s_path.stat().st_size
+                except Exception:
+                    size_bytes = len(s_content.encode("utf-8")) if s_content else 0
+
+                skill_entry = {
+                    "path": s_path,
+                    "name": p_skill_name,
+                    "folder_name": s_raw_name,
+                    "frontmatter_name": s_raw_name,
+                    "description": s_desc,
+                    "keywords": list(words),
+                    "content": s_content,
+                    "size_bytes": size_bytes,
+                }
+                skills[p_skill_name] = skill_entry
+                if s_raw_name not in skills and s_raw_name not in disabled:
+                    skills[s_raw_name] = skill_entry
     except Exception:
         pass
 

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim_cli/client_utils.py

@@ -181,10 +181,10 @@ def fetch_remote_models_catalog(timeout: float = 3.0) -> dict:
         params = {}
         try:
             from utim_cli.config import config
-            _plan = (config.get("user_plan") or "all")
-            params["tier"] = str(_plan).lower().strip()
+            _plan = str(config.get("user_plan") or "free").lower().strip()
+            params["tier"] = _plan
         except Exception:
-            params["tier"] = "all"
+            params["tier"] = "free"
         resp = requests.get(url, params=params, headers=get_auth_headers(), timeout=timeout)
         if resp.status_code == 200:
             data = resp.json()
@@ -572,6 +572,82 @@ def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None
         return requests.post("https://openrouter.ai/api/v1/chat/completions", json=json_data, headers=headers, stream=stream or json_data.get("stream"), timeout=timeout, verify=config.verify_ssl)
 
 
+def sanitize_tools_for_api(tools: Optional[List[Dict[str, Any]]], model_id: Optional[str] = None) -> Optional[List[Dict[str, Any]]]:
+    """Sanitize and validate JSON schemas in tool declarations.
+    
+    Removes unsupported JSON schema keywords (like $schema, additionalProperties, 
+    propertyNames, patternProperties, definitions), ensures arrays have valid 'items' schemas,
+    and converts uppercase / invalid type declarations that cause Google Gemini / GLM / OpenAPI
+    validators to reject payloads with 400 'Invalid JSON payload' errors.
+    """
+    if not tools:
+        return tools
+
+    TYPE_MAP = {
+        "STRING": "string",
+        "NUMBER": "number",
+        "INTEGER": "integer",
+        "BOOLEAN": "boolean",
+        "ARRAY": "array",
+        "OBJECT": "object",
+        "NULL": "null"
+    }
+
+    def _clean_schema_node(node):
+        if not isinstance(node, dict):
+            return node
+        cleaned = {}
+        disallowed_keys = {
+            "$schema", "$id", "definitions", "$defs", "propertyNames",
+            "patternProperties", "additionalProperties", "unevaluatedProperties",
+        }
+        for k, v in node.items():
+            if k in disallowed_keys:
+                continue
+
+            # Standardize JSON schema type names to lowercase
+            if k == "type":
+                if isinstance(v, str):
+                    v = TYPE_MAP.get(v, v.lower())
+                elif isinstance(v, list):
+                    v = [TYPE_MAP.get(item, item.lower()) if isinstance(item, str) else item for item in v]
+
+            if isinstance(v, dict):
+                cleaned[k] = _clean_schema_node(v)
+            elif isinstance(v, list):
+                cleaned[k] = [_clean_schema_node(item) if isinstance(item, dict) else item for item in v]
+            else:
+                cleaned[k] = v
+
+        # Strict validator fix: If type is 'array' and 'items' is missing or empty dict, default items to string or object
+        if cleaned.get("type") == "array":
+            items = cleaned.get("items")
+            if not items or items == {}:
+                cleaned["items"] = {"type": "string"}
+            elif isinstance(items, dict):
+                cleaned["items"] = _clean_schema_node(items)
+
+        # Strict validator fix: If type is 'object', ensure properties is a dict if present
+        if cleaned.get("type") == "object":
+            if "properties" in cleaned and not isinstance(cleaned["properties"], dict):
+                cleaned["properties"] = {}
+
+        return cleaned
+
+    sanitized_tools = []
+    for tool in tools:
+        if not isinstance(tool, dict):
+            continue
+        tool_copy = dict(tool)
+        if "function" in tool_copy and isinstance(tool_copy["function"], dict):
+            fn_copy = dict(tool_copy["function"])
+            if "parameters" in fn_copy and isinstance(fn_copy["parameters"], dict):
+                fn_copy["parameters"] = _clean_schema_node(fn_copy["parameters"])
+            tool_copy["function"] = fn_copy
+        sanitized_tools.append(tool_copy)
+    return sanitized_tools
+
+
 def sanitize_messages_for_api(messages, model_id: Optional[str] = None):
     """Normalize conversation history into a provider-safe shape before sending.
 

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim_cli/constants.py

@@ -11,7 +11,26 @@ SUBAGENT_DEFAULTS = {
     "analyze_image": "google/gemma-4-31b-it:free",
 }
 
-
+APINEX_MODEL_IDS = {
+    "claude/opus-5",
+    "claude/sonnet-5",
+    "deepseek/v4-flash-0731",
+    "deepseek/v4-pro-0813",
+    "free/deepseek-v4-flash-0731",
+    "free/deepseek-v4-pro-0813",
+    "free/glm-5.3-flash",
+    "free/gemini-3.1-pro",
+    "free/gemini-3.7-flash",
+    "gemini/3.1-pro",
+    "gemini/3.7-flash",
+    "kimi/k3",
+    "gpt/5.6-luna",
+    "gpt/5.6-sol",
+    "gpt/5.6-terra",
+    "glm/5.3",
+    "glm/5.3-flash",
+    "grok/4.6",
+}
 
 
 import sys
@@ -19,3 +38,4 @@ _IS_LEGACY_WIN = (sys.platform == "win32" and "WT_SESSION" not in os.environ)
 PROMPT_SYMBOL = ">" if _IS_LEGACY_WIN else "❯"
 ARROW_SYMBOL = "->" if _IS_LEGACY_WIN else "➔"
 
+

{utim_cli-2.3.17 → utim_cli-2.3.19}/utim_cli/mcp_client.py

@@ -213,7 +213,18 @@ class MCPManager:
         servers = config.get("mcpServers") or {}
         if not isinstance(servers, dict):
             servers = {}
-        
+
+        # Merge active MCP servers declared by enabled plugins
+        try:
+            from utim_cli.plugins.manager import get_plugin_manager
+            plugin_mcp = get_plugin_manager().get_active_mcp_servers()
+            if isinstance(plugin_mcp, dict):
+                for srv_name, srv_conf in plugin_mcp.items():
+                    if srv_name not in servers:
+                        servers[srv_name] = srv_conf
+        except Exception:
+            pass
+
         for name, srv_config in servers.items():
             command = srv_config.get("command")
             args = srv_config.get("args", [])