utim-cli 2.3.18__tar.gz → 2.3.19b0__tar.gz

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [2.3.19-beta] - 2026-09-03
+
+### 🚀 Beta Release: Tier Enforcement & Model Access Fixes
+- **Websearch tier gate**: agentic websearch (LLM query synthesis + synthesis) is now paid-plan only; free-tier users always get the fast non-agentic path
+- **Tool registry cleanup**: removed `analyzeimage` from callable tools — vision models receive image bytes directly via `readfile`, non-vision models get internal auto-descriptions
+- **APINEX models ungated**: APINEX models are now available on every plan (paid included) as free models
+- Version tagged as **beta** (`2.3.19-beta`) for beta-channel upload
+
+## [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

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

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

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

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim/__init__.py

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

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

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/_version.py

@@ -11,6 +11,10 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.3.18"
+# Beta release: "-beta" is the machine-valid spelling of "2.3.19 beta"
+# (npm semver prerelease tag + PEP 440 pre-release segment; a space would
+# break npm publish and pip). parse_version() strips the suffix so update
+# checks still compare on the numeric core 2.3.19.
+VERSION = "2.3.19-beta"
 
 

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/auth.py

@@ -495,8 +495,22 @@ 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 or plan_name == "free") 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:
+                        _pdata = _vr.json() or {}
+                        plan_name = _pdata.get("plan") or _pdata.get("plan_name")
+                except Exception:
+                    pass
+            clean_plan = str(plan_name or "free").lower().removesuffix(" plan").strip()
+            config.set("user_plan", clean_plan)
             if body.get("api_key"):
                 config.set("api_key", body["api_key"])
             raw_print("")

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/client_utils.py

@@ -64,6 +64,44 @@ def get_server_url() -> str:
     return "https://api.utim.dev"
 
 
+def is_paid_plan(plan_name: Optional[str]) -> bool:
+    """Return True if the given plan name represents a paid subscription tier."""
+    if not plan_name:
+        return False
+    p = str(plan_name).lower().removesuffix(" plan").strip()
+    return p not in ("free", "free tier", "", "none", "null", "guest", "undefined")
+
+
+def is_user_paid(force_refresh: bool = False) -> bool:
+    """Helper to check if the current user has an active paid subscription tier."""
+    try:
+        from utim_cli.config import config
+        api_key = config.get("api_key")
+        cached_plan = config.get("user_plan")
+
+        if not force_refresh and cached_plan and is_paid_plan(cached_plan):
+            return True
+
+        if not api_key:
+            return is_paid_plan(cached_plan)
+
+        try:
+            from utim_cli.orchestrator_helpers import get_cached_quota
+            quota = get_cached_quota(api_key, force_refresh=force_refresh)
+            if quota:
+                plan = quota.get("plan") or quota.get("plan_name")
+                if plan:
+                    clean_plan = str(plan).lower().removesuffix(" plan").strip()
+                    config.set("user_plan", clean_plan)
+                    return is_paid_plan(clean_plan)
+        except Exception:
+            pass
+
+        return is_paid_plan(cached_plan)
+    except Exception:
+        return False
+
+
 def _sanitize_json(obj):
     """Recursively scrub a payload for values that break strict JSON parsers.
 
@@ -181,10 +219,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()
@@ -1026,10 +1064,19 @@ def repair_and_normalize_tool_call(tc: dict) -> dict:
     raw_name = str(fn.get("name", "")).strip()
     raw_args = fn.get("arguments", "{}")
 
-    # 1. Clean and normalize tool name
+    raw_name_orig = raw_name
     for known in KNOWN_TOOLS:
         if raw_name.startswith(known):
+            remainder = raw_name[len(known):].strip()
             raw_name = known
+            if remainder and (not str(raw_args).strip() or str(raw_args).strip() == "{}"):
+                attrs = re.findall(r'(\w+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|\'((?:[^\'\\]|\\.)*)\'|(\S+))', remainder)
+                if attrs:
+                    parsed_attrs = {}
+                    for _k, _v1, _v2, _v3 in attrs:
+                        _v = _v1 or _v2 or _v3 or ""
+                        parsed_attrs[_k] = _v
+                    raw_args = parsed_attrs
             break
         if raw_name == known + known:
             raw_name = known

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/orchestrator.py

@@ -139,9 +139,9 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
             pass
         self.server_url = "https://api.utim.dev"
         self.session_id: Optional[str] = None
-        # Primary model — load from config or fall back to DEFAULT_MODEL
+        # Primary model — load from config (no default model selected on first startup)
         saved_main_model = config.get("main_model") or config.get("model")
-        self.model_id: str = saved_main_model if saved_main_model else DEFAULT_MODEL
+        self.model_id: Optional[str] = saved_main_model if saved_main_model else None
         self._current_line_len = 0
         self.tool_results: List[Dict[str, Any]] = []
         self.turn_step_timings: List[Dict[str, Any]] = []
@@ -501,6 +501,11 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
             self._subagent_tool_override = override_tools
         max_iterations = 500  # Continuous execution mode with milestone nudges instead of hard pauses
 
+        # If no model is configured for the main agent, prompt the user to select one
+        if not self.model_id or not str(self.model_id).strip():
+            self.console.print('\nPlease select a model by running "/model Then main agent"\n')
+            return
+
         self.turn_step_timings = []
         self._tool_failure_counts = {}
         self._tool_name_failure_counts = {}

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/orchestrator_helpers.py

@@ -244,7 +244,13 @@ def get_cached_quota(api_key: str, force_refresh: bool = False) -> Optional[Dict
                 session = get_http_session()
                 resp = session.get(f"{SERVER_URL}/quota", headers={"X-API-Key": api_key}, timeout=2.0)
                 if resp.status_code == 200:
-                    _QUOTA_CACHE.update({"data": resp.json(), "timestamp": time.time(), "api_key": api_key})
+                    data = resp.json()
+                    _QUOTA_CACHE.update({"data": data, "timestamp": time.time(), "api_key": api_key})
+                    plan = data.get("plan") or data.get("plan_name")
+                    if plan:
+                        from utim_cli.config import config
+                        clean_plan = str(plan).lower().removesuffix(" plan").strip()
+                        config.set("user_plan", clean_plan)
             except Exception:
                 pass
         threading.Thread(target=_bg_quota_refresh, daemon=True).start()
@@ -263,6 +269,11 @@ def get_cached_quota(api_key: str, force_refresh: bool = False) -> Optional[Dict
             data = resp.json()
             _QUOTA_CACHE.clear()
             _QUOTA_CACHE.update({"data": data, "timestamp": now, "api_key": api_key})
+            plan = data.get("plan") or data.get("plan_name")
+            if plan:
+                from utim_cli.config import config
+                clean_plan = str(plan).lower().removesuffix(" plan").strip()
+                config.set("user_plan", clean_plan)
             return data
     except Exception:
         pass

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/orchestrator_llm_transport.py

@@ -802,18 +802,8 @@ class LLMTransportMixin:
                                     self.model_source = "utim"
                                     config.set("main_model_source", "utim")
                         else:
-                            # Paid plan (plan != free): gate APINEX models
-                            if is_apinex:
-                                fallback_model = "anthropic/claude-3-5-sonnet-20241022"
-                                self.console.print(f"\n[bold yellow]APINEX model '{chosen_model}' is exclusively for the Free plan.[/bold yellow]")
-                                self.console.print(f"  Switching to your plan's model: '{fallback_model}'.\n")
-                                if override_model:
-                                    override_model = fallback_model
-                                else:
-                                    self.model_id = fallback_model
-                                    self.model_source = "utim"
-                                    config.set("main_model_source", "utim")
-                            elif models_allowed != ["all"] and chosen_model not in models_allowed and free_bonus_balance <= 0.0:
+                            # Paid plan: APINEX models are free gateway models — allowed on every plan
+                            if models_allowed != ["all"] and chosen_model not in models_allowed and not is_apinex and free_bonus_balance <= 0.0:
                                 fallback_model = DEFAULT_MODEL
                                 self.console.print(f"\n[bold yellow]Model '{chosen_model}' is gated under your current '{quota.get('display_name', 'Free')}' plan.[/bold yellow]")
                                 self.console.print(f"  Downgrading to default allowed model: '{fallback_model}' for this request.")
@@ -1314,8 +1304,10 @@ class LLMTransportMixin:
                                 # NOTE: last_content_time is updated further below, only when
                                 # actual content or tool-call data is parsed from the chunk.
                                     
-                                # Clean and normalize the raw line
-                                line_str = raw_line.strip()
+                                if isinstance(raw_line, bytes):
+                                    line_str = raw_line.decode("utf-8", errors="ignore").strip()
+                                else:
+                                    line_str = str(raw_line).strip()
                                 if not line_str:
                                     continue
 

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/plugins/manager.py

@@ -21,6 +21,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Set
 
 from utim_cli.config import get_utim_dir, config
+from utim_cli.client_utils import is_user_paid
 from utim_cli.plugins.schema import Plugin, PluginManifest
 from utim_cli.plugins.registry import get_registry_plugins, find_registry_plugin
 from utim_cli.plugins import loader as staged_loader
@@ -149,6 +150,8 @@ class PluginManager:
     # ── Enable / Disable / Toggle ────────────────────────────────────────────
 
     def enable_plugin(self, name: str) -> bool:
+        if not is_user_paid():
+            return False
         plugin = self.get_plugin(name)
         if not plugin:
             return False
@@ -171,6 +174,8 @@ class PluginManager:
         return True
 
     def toggle_plugin(self, name: str) -> bool:
+        if not is_user_paid():
+            return False
         return self.disable_plugin(name) if self.is_enabled(name) else self.enable_plugin(name)
 
     # ── Installation ─────────────────────────────────────────────────────────
@@ -191,6 +196,9 @@ class PluginManager:
     def install_plugin(self, identifier: str, force: bool = False, plugin_type: str = "auto") -> Dict[str, Any]:
         """Install a plugin from a registry name, git URL, or local path."""
         result: Dict[str, Any] = {"ok": False, "plugin": identifier, "message": ""}
+        if not is_user_paid():
+            result["message"] = "Plugins are only available on paid plans (Hobby plan or higher). Please upgrade your subscription at https://utim.dev/upgrade"
+            return result
         meta = find_registry_plugin(identifier)
         git_url = self._parse_git_url(identifier)
 
@@ -280,6 +288,12 @@ class PluginManager:
           • Any other page      -> knowledge plugin (scraped markdown becomes
              a SKILL.md the model gets injected with)
         """
+        if not is_user_paid():
+            return {
+                "ok": False,
+                "message": "Plugins are only available on paid plans (Hobby plan or higher). Please upgrade your subscription at https://utim.dev/upgrade",
+            }
+
         def _say(msg: str) -> None:
             if progress_cb:
                 progress_cb(msg)
@@ -392,6 +406,9 @@ class PluginManager:
 
         Returns (ok: bool, message: str, path: Optional[Path]).
         """
+        if not is_user_paid():
+            return False, "Plugins are only available on paid plans (Hobby plan or higher). Please upgrade your subscription at https://utim.dev/upgrade", None
+
         clean = re.sub(r"[^a-zA-Z0-9_\-]", "-", name.strip().lower()).strip("-")
         if not clean:
             return False, "Invalid plugin name", None
@@ -469,6 +486,8 @@ class PluginManager:
     # ── Aggregation (effectors) ──────────────────────────────────────────────
 
     def get_active_skills(self) -> Dict[str, Dict[str, Any]]:
+        if not is_user_paid():
+            return {}
         skills: Dict[str, Dict[str, Any]] = {}
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -480,6 +499,8 @@ class PluginManager:
         return skills
 
     def get_active_rules(self) -> List[Dict[str, Any]]:
+        if not is_user_paid():
+            return []
         rules: List[Dict[str, Any]] = []
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -487,6 +508,8 @@ class PluginManager:
         return rules
 
     def get_active_mcp_servers(self) -> Dict[str, Dict[str, Any]]:
+        if not is_user_paid():
+            return {}
         servers: Dict[str, Dict[str, Any]] = {}
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -494,6 +517,8 @@ class PluginManager:
         return servers
 
     def get_active_tools(self) -> List[Dict[str, Any]]:
+        if not is_user_paid():
+            return []
         tools: List[Dict[str, Any]] = []
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -511,6 +536,8 @@ class PluginManager:
         (string/dict commands from manifests) go through hooks.py in
         parallel with per-hook timeouts.
         """
+        if not is_user_paid():
+            return []
         from utim_cli.plugins import hooks as hook_engine
         payload = payload or {}
         output: Dict[str, Any] = {}

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/plugins/tool_loader.py

@@ -53,6 +53,14 @@ def load_plugin_tools(force_refresh: bool = False) -> Tuple[List[Dict], Dict[str
     if not force_refresh and _TOOL_CACHE is not None and (now - _TOOL_CACHE[2]) < _TOOL_CACHE_TTL:
         return _TOOL_CACHE[0], _TOOL_CACHE[1]
 
+    try:
+        from utim_cli.client_utils import is_user_paid
+        if not is_user_paid():
+            _TOOL_CACHE = ([], {}, now)
+            return [], {}
+    except Exception:
+        pass
+
     from utim_cli.plugins.manager import get_plugin_manager
 
     schemas: List[Dict] = []

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/server/auth.py

@@ -678,38 +678,49 @@ def _resolve_user_plan_name(user) -> str:
     Safe to call without a DB session — falls back to ``"free"`` on any error
     so that catalog gating cannot leak paid models to anonymous callers.
 
-    Expiration-aware: an ``active`` subscription whose ``end_date`` has passed
+    Expiration-aware: an ``active`` subscription whose ``current_period_end`` has passed
     (and which was never renewed) is treated as ``free`` — we do not rely on a
     background job to flip the status to ``expired``.
     """
+    if not user:
+        return "free"
     try:
-        from .db import SessionLocal, UserSubscription
+        from .db import SessionLocal, UserSubscription, Plan
         from datetime import datetime, timezone
-        subs = (
-            SessionLocal()
-            .query(UserSubscription)
-            .filter(UserSubscription.user_id == user.id, UserSubscription.status == "active")
-            .all()
-        )
-        now = datetime.now(timezone.utc)
-        best = None
-        best_end = None
-        for sub in subs:
-            if not (sub.plan and getattr(sub.plan, "name", None)):
-                continue
-            end = getattr(sub, "end_date", None)
-            # Normalise tz-aware end_date to naive UTC (or vice-versa) so the
-            # comparison never raises TypeError on mixed aware/naive values.
-            if end is not None and getattr(end, "tzinfo", None) is not None:
-                end = end.astimezone(timezone.utc).replace(tzinfo=None)
-            # Skip subscriptions that already expired.
-            if end is not None and end < now.replace(tzinfo=None):
-                continue
-            if best is None or (end is not None and (best_end is None or end > best_end)):
-                best = sub
-                best_end = end
-        if best is not None:
-            return str(best.plan.name).lower()
+        db = SessionLocal()
+        try:
+            subs = (
+                db.query(UserSubscription)
+                .filter(UserSubscription.user_id == user.id, UserSubscription.status == "active")
+                .order_by(UserSubscription.updated_at.desc(), UserSubscription.created_at.desc())
+                .all()
+            )
+            now = datetime.now(timezone.utc)
+            best = None
+            best_end = None
+            for sub in subs:
+                plan = sub.plan
+                if not plan and sub.plan_id:
+                    plan = db.query(Plan).filter((Plan.id == sub.plan_id) | (Plan.name == sub.plan_id)).first()
+                if not plan or not getattr(plan, "name", None):
+                    continue
+                end = getattr(sub, "current_period_end", None) or getattr(sub, "end_date", None)
+                # Normalise tz-aware end date to naive UTC so the comparison never raises TypeError.
+                if end is not None and getattr(end, "tzinfo", None) is not None:
+                    end = end.astimezone(timezone.utc).replace(tzinfo=None)
+                # Skip subscriptions that already expired.
+                if end is not None and end < now.replace(tzinfo=None):
+                    continue
+                plan_name = str(plan.name).lower().strip()
+                if plan_name != "free":
+                    return plan_name
+                if best is None or (end is not None and (best_end is None or end > best_end)):
+                    best = plan_name
+                    best_end = end
+            if best is not None:
+                return best
+        finally:
+            db.close()
     except Exception:
         pass
     return "free"

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/server/models.py

@@ -2919,12 +2919,12 @@ def _tier_derived_allowlist(plan_name: str) -> set:
         return set()
     out = set()
     for mid, entry in (MODEL_REGISTRY or {}).items():
-        # APINEX models are exclusively for free plan users; gate for paid plans
-        if norm_name != "free" and (getattr(entry, "provider", "").lower() == "apinex" or mid in APINEX_MODEL_IDS):
-            continue
+        # APINEX models are free gateway models — included on every plan
         rank = _MODEL_TIER_RANK.get(_model_tier_of(entry), 2)  # default mid
         if rank in keep:
             out.add(mid)
+    # Always append APINEX gateway models (zero-cost, free on all plans)
+    out.update(APINEX_MODEL_IDS)
     return out
 
 
@@ -3141,8 +3141,8 @@ def get_model_catalog(user_tier: str = "all") -> dict:
     # ── Per-tier gating ────────────────────────────────────────────────────
     # Each plan has a `Plan.allowed_models` column ("free" | "all" | comma-list).
     # We use it to:
-    #   1) Free users → see `is_free` items and all APINEX models (exclusive to free tier)
-    #   2) Paid users (hobby, pro, max, ultimate, etc.) → APINEX models are hidden; paid models shown
+    #   1) Free users → see `is_free` items and all APINEX models (free gateway models)
+    #   2) Paid users (hobby, pro, max, ultimate, etc.) → paid models shown; APINEX models also available
     #   3) "all" sentinel / admin view → all models returned
     normalized_tier = (user_tier or "all").strip().lower()
     is_free_user = normalized_tier in ("free", "free_tier", "default")
@@ -3158,7 +3158,7 @@ def get_model_catalog(user_tier: str = "all") -> dict:
     if is_free_user:
         def _is_free_item(it: dict) -> bool:
             # Free users see:
-            # 1) items with provider == "apinex" (APINEX models are exclusively for free plan)
+            # 1) items with provider == "apinex" (free gateway models, zero cost)
             # 2) standard free models (is_free or tier == "free" or ending with ":free")
             is_apx = (str(it.get("provider", "")).lower() == "apinex")
             return is_apx or bool(it.get("is_free")) or (it.get("tier") == "free") or str(it.get("model_id", "")).endswith(":free")
@@ -3167,10 +3167,7 @@ def get_model_catalog(user_tier: str = "all") -> dict:
             payload[key] = [it for it in payload[key] if _is_free_item(it)]
     else:
         # Non-free users:
-        # For paid plan tiers (hobby, pro, max, ultimate, enterprise), APINEX models must NOT show up
-        if not is_all_user:
-            for key in ("main_agent", "plan_project", "subagent_text", "analyze_image", "image_gen", "all_text"):
-                payload[key] = [it for it in payload[key] if str(it.get("provider", "")).lower() != "apinex"]
+        # APINEX models are free gateway models (zero cost) — they remain available on paid plans too.
 
         # Paid plan: look up the Plan row's `allowed_models`
         try:

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/server/routes/auth_routes.py

@@ -287,6 +287,8 @@ async def device_poll(device_code: str, request: Request, db: Session = Depends(
         if code.status == "authorized":
             # Return the api_key and burn the code immediately (one-time use)
             user = db.query(User).filter(User.id == code.user_id).first()
+            from ..auth import _resolve_user_plan_name
+            user_plan = _resolve_user_plan_name(user) if user else "free"
             result = {
                 "status": "authorized",
                 "api_key": code.api_key,
@@ -295,6 +297,8 @@ async def device_poll(device_code: str, request: Request, db: Session = Depends(
                 "user_id": code.user_id,
                 "firebase_uid": user.firebase_uid if user else "",
                 "credits": user.credits.balance if user and user.credits else 0,
+                "plan": user_plan,
+                "is_subscribed": user_plan != "free",
             }
             # Invalidate: delete the row so this device_code can never be reused
             db.delete(code)

{utim_cli-2.3.18 → utim_cli-2.3.19b0}/utim_cli/server/routes/completion_routes.py

@@ -80,7 +80,7 @@ def is_model_allowed(model_id: str, allowed_models_str: str, bonus_balance: floa
     """Check if a model is allowed for the user's plan.
     
     If bonus_balance > 0 on any plan (including free), all models are unlocked.
-    APINEX models are exclusively available on the Free plan and gated on paid plans.
+    APINEX models are free gateway models (zero cost) and are allowed on every plan.
     """
     allowed_tokens = [t.strip() for t in allowed_models_str.split(",")]
     is_free_plan = "free" in allowed_tokens and len(allowed_tokens) == 1
@@ -91,12 +91,9 @@ def is_model_allowed(model_id: str, allowed_models_str: str, bonus_balance: floa
         or (entry and getattr(entry, "provider", "").lower() == "apinex")
     )
 
-    # 1. APINEX models: allowed on Free plan, gated on paid plans
+    # 1. APINEX models: free gateway models — allowed on ALL plans (free + paid)
     if is_apinex_model:
-        if is_free_plan or "free" in allowed_tokens:
-            return True
-        # Paid plan: APINEX models are gated for paid users
-        return False
+        return True
 
     if bonus_balance > 0.0:
         return True
@@ -204,12 +201,14 @@ def _effective_allowed_models(plan_name: str, plan_allowed_models: str) -> str:
         keep = ranks_for_plan.get(name, {0, 1, 2, 3, 4})
         out = []
         for mid, entry in (MODEL_REGISTRY or {}).items():
-            # APINEX models are exclusively for free plan users; gate for paid plans
-            if name != "free" and (getattr(entry, "provider", "").lower() == "apinex" or mid in APINEX_MODEL_IDS):
-                continue
+            # APINEX models are free gateway models — included on every plan
             entry_rank = _MODEL_TIER_RANK.get(_model_tier_of(entry), 2)  # default mid
             if entry_rank in keep:
                 out.append(mid)
+        # Always append APINEX gateway models (zero-cost, free on all plans)
+        for ap_id in APINEX_MODEL_IDS:
+            if ap_id not in out:
+                out.append(ap_id)
         if out:
             return ",".join(out)
     except Exception:
@@ -1412,6 +1411,7 @@ def deduct_credits_unallocated_first(db: Session, user: User, credits_cost: floa
             if unallocated > 0.0:
                 take = min(cost_to_charge, unallocated)
                 sub_row.unallocated_deducted = unallocated_deducted + take
+                charged_to_monthly += take
                 cost_to_charge -= take
                 
         # 3. credit.balance (Quota Bank / Rollover)