utim-cli 2.3.16__tar.gz → 2.3.18__tar.gz

{utim_cli-2.3.16 → utim_cli-2.3.18}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [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
+- Free-plan users with bonus credits can now see premium models in the model catalog (server-side `/models/catalog` and client-side TUI gating)
+- Added bonus-credit detection helper with caching and graceful offline fallback
+- Bonus credits are deducted exclusively when premium completions finish; visibility switches back automatically once the balance is exhausted
+
 ## [2.3.16] - 2026-08-29
 
 ### 🛠️ Minor Enhancements and Bug Fixes

{utim_cli-2.3.16/utim_cli.egg-info → utim_cli-2.3.18}/PKG-INFO

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

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

{utim_cli-2.3.16 → utim_cli-2.3.18}/utim/__init__.py

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

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

{utim_cli-2.3.16 → utim_cli-2.3.18}/utim_cli/_version.py

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

utim_cli-2.3.18/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.16 → utim_cli-2.3.18}/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.16 → utim_cli-2.3.18}/utim_cli/client_utils.py

@@ -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.16 → utim_cli-2.3.18}/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.16 → utim_cli-2.3.18}/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", [])

{utim_cli-2.3.16 → utim_cli-2.3.18}/utim_cli/orchestrator.py

@@ -99,25 +99,23 @@ from .orchestrator_helpers import (  # noqa: F401,E402
 )
 
 
-class _ServerUnavailableError(RuntimeError):
-    """Raised when the UTIM server cannot be reached and no local key is configured.
-    Caught in run_task to display a clean user-facing message (no traceback).
-    """
-
-
-class _FatalClientError(RuntimeError):
-    """Raised when a non-retryable gating or credit validation error occurs.
-    Caught in run_task to immediately abort the turn without retry.
-    """
-
-
 from .orchestrator_tool_exec import ToolExecutionMixin  # noqa: E402
 
 
 from .orchestrator_turn_history import TurnHistoryMixin  # noqa: E402
 
 
-from .orchestrator_llm_transport import LLMTransportMixin  # noqa: E402
+from .orchestrator_llm_transport import (  # noqa: E402,F401
+    LLMTransportMixin,
+    # ── IMPORTANT: bind the transport's exception classes here ──
+    # The transport raises ITS OWN _ServerUnavailableError/_FatalClientError.
+    # Previously orchestrator.py defined duplicate same-named classes, so
+    # `except _FatalClientError` never caught transport-raised errors and
+    # quota/rate-limit failures fell into the generic transient-retry loop
+    # ("Transient error on iteration 1 … Retrying in 3s…" x3 then abort).
+    _ServerUnavailableError,
+    _FatalClientError,
+)
 
 
 class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):

{utim_cli-2.3.16 → utim_cli-2.3.18}/utim_cli/orchestrator_helpers.py

@@ -269,6 +269,57 @@ def get_cached_quota(api_key: str, force_refresh: bool = False) -> Optional[Dict
     return _QUOTA_CACHE.get("data")
 
 
+def format_quota_reset_countdown(reset_at_iso: Optional[str]) -> Tuple[str, str]:
+    """Parse ISO reset timestamp and return (countdown_str, human_time_str).
+
+    countdown_str format: '1h:45m', '0h:32m', etc.
+    human_time_str format: '2026-09-02 02:45 UTC' or 'momentarily'
+    """
+    if not reset_at_iso:
+        return "in a few hours", "next refill window"
+
+    try:
+        from datetime import datetime, timezone
+        clean_iso = str(reset_at_iso).strip()
+        if clean_iso.endswith("+00:00Z"):
+            clean_iso = clean_iso[:-1]
+        elif clean_iso.endswith("Z"):
+            if "+" not in clean_iso and "-" not in clean_iso[10:]:
+                clean_iso = clean_iso[:-1] + "+00:00"
+            else:
+                clean_iso = clean_iso[:-1]
+
+        try:
+            reset_dt = datetime.fromisoformat(clean_iso)
+        except ValueError:
+            clean_iso_alt = str(reset_at_iso).strip().replace("Z", "+00:00")
+            reset_dt = datetime.fromisoformat(clean_iso_alt)
+
+        now_dt = datetime.now(timezone.utc)
+        if reset_dt.tzinfo is None:
+            reset_dt = reset_dt.replace(tzinfo=timezone.utc)
+
+        diff = reset_dt - now_dt
+        total_seconds = max(0, int(round(diff.total_seconds())))
+        if total_seconds <= 30:
+            return "0h:01m", "momentarily"
+
+        total_minutes = int(round(total_seconds / 60.0))
+        hours = total_minutes // 60
+        minutes = total_minutes % 60
+        countdown = f"{hours}h:{minutes:02d}m" if hours > 0 else f"0h:{minutes:02d}m"
+        human_time = reset_dt.strftime("%Y-%m-%d %H:%M UTC")
+        return countdown, human_time
+    except Exception:
+        return "in a few hours", str(reset_at_iso)
+
+
+def invalidate_quota_cache() -> None:
+    """Invalidate in-memory quota cache to force a fresh server check."""
+    global _QUOTA_CACHE
+    _QUOTA_CACHE["timestamp"] = 0
+
+
 from utim_cli.config import get_utim_dir
 _utim_dir_posix = get_utim_dir().as_posix()
 
@@ -1252,7 +1303,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
             for pr in active_plugin_rules:
                 p_content = pr.get("content", "").strip()
                 p_name = pr.get("name", "plugin_rule")
-                p_plugin = pr.get("plugin_name", "plugin")
+                p_plugin = pr.get("plugin_name") or pr.get("plugin") or "plugin"
                 if p_content:
                     plugin_rules_blocks.append(f"#### Plugin Rule [{p_plugin} / {p_name}]\n{p_content}")
             if plugin_rules_blocks:
@@ -1354,6 +1405,66 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
     except Exception:
         pass
 
+    plugins_prompt = ""
+    try:
+        from utim_cli.plugins.manager import get_plugin_manager
+        from utim_cli.config import get_utim_dir
+        p_mgr = get_plugin_manager()
+        discovered_plugins = p_mgr.discover_plugins()
+        global_plugins_path = str((get_utim_dir() / "plugins").resolve()).replace("\\", "/")
+        workspace_plugins_path = str((p_mgr.workspace_plugins_dir).resolve()).replace("\\", "/")
+
+        plugin_lines = []
+        for pname, p in sorted(discovered_plugins.items(), key=lambda x: x[0]):
+            status = "active (enabled)" if p.enabled and p.is_valid else ("disabled" if not p.enabled else "invalid")
+            p_path_str = str(p.path.resolve()).replace("\\", "/")
+            counts = p.get_summary_counts()
+            details = []
+            if counts.get("skills"):
+                skill_names = [s.get("raw_name", s.get("name")) for s in p.get_skills()]
+                details.append(f"skills: {', '.join(skill_names)}")
+            if counts.get("rules"):
+                rule_names = [r.get("name") for r in p.get_rules()]
+                details.append(f"rules: {', '.join(rule_names)}")
+            if counts.get("tools"):
+                tool_names = [t.get("name") for t in p.get_tools()]
+                details.append(f"native tools: {', '.join(tool_names)}")
+            if counts.get("mcp"):
+                mcp_names = list(p.get_mcp_servers().keys())
+                details.append(f"mcp servers: {', '.join(mcp_names)}")
+            if counts.get("hooks"):
+                hook_names = list(p.get_hooks().keys())
+                details.append(f"hooks: {', '.join(hook_names)}")
+
+            detail_str = f" [{'; '.join(details)}]" if details else ""
+            desc = f" — {p.description}" if p.description else ""
+            plugin_lines.append(f"- **{p.name}** (v{p.version}, {p.source}, status: {status}, path: file:///{p_path_str}){desc}{detail_str}")
+
+        if plugin_lines:
+            plugins_prompt = (
+                f"\n\n### INSTALLED & ACTIVE PLUGINS ###\n"
+                f"Global Plugins Directory: file:///{global_plugins_path}\n"
+                f"Workspace Plugins Directory: file:///{workspace_plugins_path}\n\n"
+                f"The following plugins are registered in the environment:\n"
+                + "\n".join(plugin_lines) + "\n\n"
+                f"Plugin capabilities:\n"
+                f"- **Skills**: Specialized instructions matching tasks; read their SKILL.md via `read_file` when relevant.\n"
+                f"- **Rules**: Plugin guidelines and coding standards automatically applied to code generation.\n"
+                f"- **Tools**: Native callable python/shell tools namespaced as `<plugin>__<tool>`.\n"
+                f"- **MCP Servers**: Model Context Protocol servers automatically started to provide external tools.\n"
+                f"- **Hooks**: Lifecycle hooks triggered on session/agent events.\n"
+                f"- Users can manage plugins via `/plugins` interactive menu or CLI (`/plugin list`, `/plugin info <name>`, `/plugin enable <name>`, `/plugin disable <name>`, `/plugin install <name/url>`, `/plugin create <name>`).\n"
+            )
+        else:
+            plugins_prompt = (
+                f"\n\n### PLUGINS DIRECTORY & CONFIGURATION ###\n"
+                f"Global Plugins Directory: file:///{global_plugins_path}\n"
+                f"Workspace Plugins Directory: file:///{workspace_plugins_path}\n"
+                f"Plugins extend UTIM with bundled skills, rules, tools, MCP servers, and hooks. Use `/plugins` to browse and install plugins.\n"
+            )
+    except Exception:
+        pass
+
     session_summary = ""
     import os
     from utim_cli.config import get_utim_dir
@@ -1392,7 +1503,7 @@ def get_frozen_system_prompt(user_prompt: str = "", current_iteration: int = 0,
     except Exception:
         personality_prompt = ""
 
-    return base_prompt + rules_prompt + mcp_prompt + skills_prompt + session_prompt + personality_prompt
+    return base_prompt + rules_prompt + mcp_prompt + plugins_prompt + skills_prompt + session_prompt + personality_prompt
 
 
 def get_live_context_block(user_prompt: str = "", messages: Optional[List[Dict]] = None) -> str: