utim-cli 1.47.0__tar.gz → 1.47.2__tar.gz

{utim_cli-1.47.0 → utim_cli-1.47.2}/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [1.47.2] - 2026-07-18
+
+### Fixed
+- **UnboundLocalError in Command Output Renderer**: Pre-initialized stdout and stderr lines lists in `_render_result` to prevent runtime exception on commands yielding empty output.
+- **Chunk-Boundary Unicode Decode Errors**: Upgraded `read_file` tool to slice trailing incomplete bytes during UTF-8 checks, preventing decoding failures on split multi-byte character boundaries.
+- **Reflection Engine Skill Creation Guardrail**: Restructured reflection engine to only create new skill files when at least 3 substantial guidelines (each >= 40 characters) are suggested, preventing clutter from useless "one-liner" skills.
+- **Console Status Spinner Fallback**: Patched the `console.status` spinner in `utim.py` to check for legacy Windows CMD/conhost and non-UTF-8 environments, dynamically falling back to ASCII `line` spinners instead of unicode dots.
+- **Support Chat Model Casing**: Updated frontend support assistant to target `openrouter/free` exclusively to maintain service reliability.
+
+## [1.47.1] - 2026-07-18
+
+### Added
+- **Referral Program**: Launched a full referral system. Referrers earn a 2% per-plan discount for each referred user who purchases a subscription. Discounts stack per-plan up to 100% (fully free). Every payment renewal by a referee adds another 2%. Referral dashboard available at `/referral` with live discount breakdown, progress bars, copy-ready referral link/code, and a leaderboard.
+- **Instant Server-Side Deletion**: Connected client share deletion to a new `DELETE /shares/delete/{share_id}` server endpoint to destroy shared zip packages and metadata instantly when removed from the CLI dashboard.
+- **Custom Exclude Checklist Option**: Embedded a dynamic `[ Add custom files/folders... ]` checkbox directly into the share wizard to prompt for custom omits only when selected, rather than asking unconditionally.
+- **Exclusion Path Root Validation**: Added validation to reject and display warnings for typed/pasted custom paths that fall outside the current workspace root directory.
+- **Ctrl+D Dashboard Shortcut**: Resolved key collision where pressing `D` got typed in the default-focused search bar by binding `Ctrl+D` globally to delete the active share.
+
+### Fixed
+- **Content Security Policy Alignment**: Added `https://ipapi.co` and `https://analytics.google.com` to Netlify's `connect-src` CSP header rules, allowing the website frontend to complete geolocated IP checking and analytics telemetry during startup without throwing console errors or blocking the AI chat component.
+- **Unicode Markdown Rendering Fallbacks**: Patched Rich's markdown rule, table, and list item components to detect legacy Command Prompt terminals and fallback to safe ASCII representations (`*` for bullets, `-` for rules, and `+--+` for table grids) instead of throwing UnicodeEncodeErrors or printing replacement boxes.
+- **Unicode Fallback Spinners**: Re-engineered all loading/thinking spinners and progress bar characters to detect legacy Windows CMD/conhost terminals and non-UTF-8 console environments, falling back to clean ASCII patterns (`['|', '/', '-', '\\']` and `[#---]`) to prevent rendering boxes/question marks.
+- **Graceful Prompt-Toolkit Dialog Exits**: Introduced a safe-exit mechanism to catch and prevent unhandled `Application.exit()` loop exceptions.
+- **NameError in share_tui.py**: Added typing imports to fix NameError in interactive dialogs.
+- **Server upload limit**: Raised file upload threshold from 25MB to 1GB and enforced plan-specific limits.
+- **Bonus quota tracking**: Fixed regular quota deduction when prioritizing bonus credit quota.
+- **Bonus limit display**: Standardized bonus quota percent relative to maximum allowed plan capacity and added available vs max credits indicator.
+- **Quota preference override**: Fixed schema bug to honor X-Preferred-Quota client header.
+
 ## [1.47.0] - 2026-07-17
 
 ### Added

{utim_cli-1.47.0/utim_cli.egg-info → utim_cli-1.47.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 1.47.0
+Version: 1.47.2
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev

{utim_cli-1.47.0 → utim_cli-1.47.2}/pyproject.toml

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

{utim_cli-1.47.0 → utim_cli-1.47.2}/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__ = "1.47.0"
+    __version__ = "1.47.2"
 
 import builtins, os, pathlib, urllib.parse, re
 
@@ -65,3 +65,50 @@ def _utim_print(*args, **kwargs):
 
 # Override the global print for this package
 builtins.print = _utim_print
+
+# ── Monkeypatch Rich for Legacy Windows Terminals ──
+try:
+    import rich.rule
+    import rich.markdown
+    import rich.table
+    import rich.box
+    import rich.segment
+    import sys
+    
+    _IS_LEGACY_WIN = (sys.platform == "win32" and "WT_SESSION" not in os.environ)
+    is_legacy = _IS_LEGACY_WIN or getattr(sys.stdout, 'encoding', '').lower() not in ('utf-8', 'utf8', 'cp65001')
+    
+    if is_legacy:
+        # 1. Patch Rule.__init__ to use '-' instead of '─'
+        _original_rule_init = rich.rule.Rule.__init__
+        def _patched_rule_init(self, title="", *, characters="─", style="rule.line", end="\n", align="center"):
+            if characters == "─":
+                characters = "-"
+            _original_rule_init(self, title, characters=characters, style=style, end=end, align=align)
+        rich.rule.Rule.__init__ = _patched_rule_init
+
+        # 2. Patch Table.__init__ to force ASCII box borders
+        _original_table_init = rich.table.Table.__init__
+        def _patched_table_init(self, *args, **kwargs):
+            if "box" in kwargs and kwargs["box"] is not None:
+                kwargs["box"] = rich.box.ASCII
+            elif len(args) > 0:
+                args = list(args)
+                if args[0] is not None:
+                    args[0] = rich.box.ASCII
+            _original_table_init(self, *args, **kwargs)
+        rich.table.Table.__init__ = _patched_table_init
+
+        # 3. Patch ListItem.render_bullet to use '*' instead of '•'
+        _original_render_bullet = rich.markdown.ListItem.render_bullet
+        def _patched_render_bullet(self, console, options):
+            from rich.segment import Segment
+            for item in _original_render_bullet(self, console, options):
+                if hasattr(item, "text") and item.text == " \u2022 ":
+                    yield Segment(" * ", item.style, item.control)
+                else:
+                    yield item
+        rich.markdown.ListItem.render_bullet = _patched_render_bullet
+
+except Exception:
+    pass

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/_version.py

@@ -11,4 +11,4 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "1.47.0"
+VERSION = "1.47.2"

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/config.py

@@ -76,6 +76,7 @@ class Config:
                 "Chrome/120.0.0.0 Safari/537.36"
             )
             _original_request = _req_mod.Session.request
+            config_instance = self
 
             def _ua_patched_request(self, method, url, *args, **kwargs):
                 # Merge headers so we never overwrite a caller-supplied User-Agent
@@ -85,6 +86,11 @@ class Config:
                 else:
                     hdrs = dict(hdrs)
                 hdrs.setdefault("User-Agent", _BROWSER_UA)
+                
+                # Append user's preferred quota preference to headers
+                pref = config_instance.get("preferred_quota", "regular")
+                hdrs.setdefault("X-Preferred-Quota", pref)
+                
                 kwargs["headers"] = hdrs
 
                 primary_host = "api.utim.dev"

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/orchestrator.py

@@ -2330,6 +2330,8 @@ class Orchestrator:
             stdout_section = ""
             stderr_section = ""
             current_section = None
+            stdout_lines = []
+            stderr_lines = []
 
             for line in raw_output.splitlines():
                 if line.startswith("[exit_code:"):

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/reflection.py

@@ -969,15 +969,24 @@ def apply_skill_modifications(skill_modifications: Dict[str, List[str]]):
 
         for skill_path in paths_to_write:
             try:
-                # Ensure parent directory exists
-                skill_path.parent.mkdir(parents=True, exist_ok=True)
+                skill_exists = skill_path.exists()
+                
+                # Filter rules by length and substance based on whether the skill already exists
+                min_len = 25 if skill_exists else 40
+                valid_rules = [r.strip() for r in new_rules if r and len(r.strip()) >= min_len]
+                
+                # Enforce strict guardrail for new skills: must have at least 3 substantial rules
+                if not skill_exists and len(valid_rules) < 3:
+                    continue  # Ignore creation of this new skill entirely
                 
                 content = ""
-                if skill_path.exists():
+                if skill_exists:
                     with open(skill_path, 'r', encoding='utf-8') as f:
                         content = f.read()
                     
                 if not content:
+                    # Ensure parent directory exists before writing
+                    skill_path.parent.mkdir(parents=True, exist_ok=True)
                     # Initialize a new skill md template
                     title_name = skill_name.replace('-', ' ').title()
                     content = f"""---
@@ -992,10 +1001,7 @@ description: Automatically learned guidelines for {title_name}.
                 
                 # Append new rules avoiding duplicates
                 rules_to_add = []
-                for rule in new_rules:
-                    rule_clean = rule.strip()
-                    if not rule_clean:
-                        continue
+                for rule_clean in valid_rules:
                     # Check if already present in content (case-insensitive substring check)
                     if rule_clean.lower() not in content.lower():
                         rules_to_add.append(rule_clean)

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/server/db.py

@@ -54,7 +54,10 @@ class User(Base):
     created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
     last_project_folder = Column(Text, nullable=True)
     firebase_uid = Column(String(128), nullable=True, index=True)
+    referrer_id = Column(String(36), ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    referral_code = Column(String(50), unique=True, nullable=False, default=lambda: uuid.uuid4().hex[:8])
 
+    referrer = relationship("User", remote_side=[id], backref="referees")
     credits = relationship("Credit", back_populates="user", uselist=False, cascade="all, delete-orphan")
     conversations = relationship("Conversation", back_populates="user", cascade="all, delete-orphan")
     transactions = relationship("Transaction", back_populates="user", cascade="all, delete-orphan")
@@ -434,6 +437,20 @@ class EmailTracking(Base):
     updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)
 
 
+class UsedEmailBonus(Base):
+    """Tracks email addresses that have claimed a first purchase bonus for specific plans.
+    
+    Importantly, this table does NOT have a foreign key to the users table, and is not cascading.
+    This prevents users from deleting their accounts and creating new ones to re-claim bonuses.
+    """
+    __tablename__ = "used_email_bonuses"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    email = Column(String(255), nullable=False, index=True)
+    plan_id = Column(String(50), nullable=False)
+    claimed_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
+
+
 # ── Bootstrap ─────────────────────────────────────────────────────────────────
 
 def init_db(silent: bool = True) -> None:
@@ -458,6 +475,14 @@ def init_db(silent: bool = True) -> None:
     # Run manual migrations for missing columns
     # Each ALTER runs in its OWN transaction so one failure doesn't block the rest.
     from sqlalchemy import text, inspect as sa_inspect
+
+    # Ensure referral_discounts table exists (defined in referral_routes, not imported into Base yet)
+    try:
+        from .routes.referral_routes import ReferralDiscount
+        Base.metadata.create_all(bind=engine, tables=[ReferralDiscount.__table__])
+    except Exception as _ref_tbl_exc:
+        _print(f"[DB INIT] referral_discounts table init note: {_ref_tbl_exc}")
+
     is_postgres = DATABASE_URL.startswith("postgresql")
 
     try:
@@ -498,6 +523,8 @@ def init_db(silent: bool = True) -> None:
         _print("[DB INIT] Postgres detected. Running ALTER TABLE migrations if needed.")
         _run_migration("credits", "free_monthly_used", "ALTER TABLE credits ADD COLUMN IF NOT EXISTS free_monthly_used FLOAT DEFAULT 0.0 NOT NULL", "postgres add free_monthly_used")
         _run_migration("users", "firebase_uid", "ALTER TABLE users ADD COLUMN IF NOT EXISTS firebase_uid VARCHAR(128)", "postgres add firebase_uid")
+        _run_migration("users", "referrer_id", "ALTER TABLE users ADD COLUMN IF NOT EXISTS referrer_id VARCHAR(36)", "postgres add referrer_id")
+        _run_migration("users", "referral_code", "ALTER TABLE users ADD COLUMN IF NOT EXISTS referral_code VARCHAR(50)", "postgres add referral_code")
         _run_migration("feedbacks", "chat_history", "ALTER TABLE feedbacks ADD COLUMN IF NOT EXISTS chat_history TEXT", "postgres add chat_history")
     else:
         # SQLite: no IF NOT EXISTS on ADD COLUMN, swallow duplicate errors
@@ -512,6 +539,8 @@ def init_db(silent: bool = True) -> None:
         _run_migration("email_tracking", "bonus_email_sent_at", "ALTER TABLE email_tracking ADD COLUMN bonus_email_sent_at TIMESTAMP", "sqlite add bonus_email_sent_at")
         _run_migration("users", "last_project_folder", "ALTER TABLE users ADD COLUMN last_project_folder TEXT", "sqlite add last_project_folder")
         _run_migration("users", "firebase_uid", "ALTER TABLE users ADD COLUMN firebase_uid VARCHAR(128)", "sqlite add firebase_uid")
+        _run_migration("users", "referrer_id", "ALTER TABLE users ADD COLUMN referrer_id VARCHAR(36)", "sqlite add referrer_id")
+        _run_migration("users", "referral_code", "ALTER TABLE users ADD COLUMN referral_code VARCHAR(50)", "sqlite add referral_code")
         _run_migration("feedbacks", "chat_history", "ALTER TABLE feedbacks ADD COLUMN chat_history TEXT", "sqlite add feedbacks chat_history")
         
     # Seed the plans if they don't exist
@@ -536,8 +565,8 @@ def init_db(silent: bool = True) -> None:
                     id="hobby",
                     name="hobby",
                     display_name="Hobby",
-                    price_inr=499,
-                    credits_per_month=3500,
+                    price_inr=700,
+                    credits_per_month=4000,
                     allowed_models="all",
                     max_context_k=256
                 ),
@@ -545,8 +574,8 @@ def init_db(silent: bool = True) -> None:
                     id="pro",
                     name="pro",
                     display_name="Pro",
-                    price_inr=1999,
-                    credits_per_month=15000,
+                    price_inr=2500,
+                    credits_per_month=18000,
                     allowed_models="all",
                     max_context_k=1024
                 ),
@@ -554,7 +583,7 @@ def init_db(silent: bool = True) -> None:
                     id="max",
                     name="max",
                     display_name="Max",
-                    price_inr=4999,
+                    price_inr=5500,
                     credits_per_month=45000,
                     allowed_models="all",
                     max_context_k=1024
@@ -581,7 +610,7 @@ def init_db(silent: bool = True) -> None:
                     id="ultimate",
                     name="ultimate",
                     display_name="Ultimate Core",
-                    price_inr=9999,
+                    price_inr=11000,
                     credits_per_month=90000,
                     allowed_models="all",
                     max_context_k=1024
@@ -590,15 +619,22 @@ def init_db(silent: bool = True) -> None:
             db.add_all(plans)
             db.commit()
         else:
-            # Update existing plan prices if needed
+            # Update existing plan details
             pro_plan = db.query(Plan).filter(Plan.id == "pro").first()
-            if pro_plan and pro_plan.price_inr != 1999:
-                pro_plan.price_inr = 1999
+            if pro_plan:
+                if pro_plan.credits_per_month != 18000:
+                    pro_plan.credits_per_month = 18000
+                if pro_plan.price_inr != 2500:
+                    pro_plan.price_inr = 2500
 
-            # ── Live migration: fix Hobby plan's stale allowed_models stub ──
             hobby_plan = db.query(Plan).filter(Plan.id == "hobby").first()
-            if hobby_plan and hobby_plan.allowed_models != "all":
-                hobby_plan.allowed_models = "all"
+            if hobby_plan:
+                if hobby_plan.credits_per_month != 4000:
+                    hobby_plan.credits_per_month = 4000
+                if hobby_plan.allowed_models != "all":
+                    hobby_plan.allowed_models = "all"
+                if hobby_plan.price_inr != 700:
+                    hobby_plan.price_inr = 700
 
             max_plan = db.query(Plan).filter(Plan.id == "max").first()
             if not max_plan:
@@ -606,7 +642,7 @@ def init_db(silent: bool = True) -> None:
                     id="max",
                     name="max",
                     display_name="Max",
-                    price_inr=4999,
+                    price_inr=5500,
                     credits_per_month=45000,
                     allowed_models="all",
                     max_context_k=1024
@@ -614,8 +650,8 @@ def init_db(silent: bool = True) -> None:
             else:
                 if max_plan.credits_per_month != 45000:
                     max_plan.credits_per_month = 45000
-                if max_plan.price_inr != 4999:
-                    max_plan.price_inr = 4999
+                if max_plan.price_inr != 5500:
+                    max_plan.price_inr = 5500
 
             ultimate_plan = db.query(Plan).filter(Plan.id == "ultimate").first()
             if not ultimate_plan:
@@ -623,7 +659,7 @@ def init_db(silent: bool = True) -> None:
                     id="ultimate",
                     name="ultimate",
                     display_name="Ultimate Core",
-                    price_inr=9999,
+                    price_inr=11000,
                     credits_per_month=90000,
                     allowed_models="all",
                     max_context_k=1024
@@ -631,8 +667,19 @@ def init_db(silent: bool = True) -> None:
             else:
                 if ultimate_plan.credits_per_month != 90000:
                     ultimate_plan.credits_per_month = 90000
-                if ultimate_plan.price_inr != 9999:
-                    ultimate_plan.price_inr = 9999
+                if ultimate_plan.price_inr != 11000:
+                    ultimate_plan.price_inr = 11000
+            
+            # Generate referral codes for existing users that don't have one
+            try:
+                users_without_code = db.query(User).filter(User.referral_code == None).all()
+                if users_without_code:
+                    _print(f"[DB INIT] Generating referral codes for {len(users_without_code)} users...")
+                    for u in users_without_code:
+                        u.referral_code = uuid.uuid4().hex[:8]
+            except Exception as ref_exc:
+                _print(f"[DB INIT] Referral code migration check failed: {ref_exc}")
+                
             db.commit()
     except Exception as exc:
         db.rollback()
@@ -650,3 +697,18 @@ def get_db():
         yield db
     finally:
         db.close()
+
+
+def get_max_bonus_limit(plan_id: str) -> float:
+    pid = (plan_id or "free").lower().strip()
+    if pid == "free":
+        return 20000.0
+    elif pid == "hobby":
+        return 50000.0
+    elif pid == "pro":
+        return 1500000.0
+    elif pid in ("max", "team"):
+        return 3000000.0
+    elif pid in ("ultimate", "enterprise"):
+        return 4500000.0
+    return 20000.0

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/server/exchange_rate.py

@@ -13,32 +13,46 @@ class ExchangeRateStore:
 
     @classmethod
     def fetch_live_rate(cls) -> float:
+        # 1. Try ER-API (reliable, free, updated daily)
         try:
-            # Try Frankfurter API (reliable, free, no key)
-            response = requests.get("https://api.frankfurter.app/latest?from=USD&to=INR", timeout=10)
+            response = requests.get("https://open.er-api.com/v6/latest/USD", timeout=5)
             if response.status_code == 200:
                 data = response.json()
                 rate = data.get("rates", {}).get("INR")
                 if rate:
                     cls.USD_TO_INR = float(rate)
-                    logger.info(f"Successfully fetched live exchange rate: {cls.USD_TO_INR}")
+                    logger.info(f"Successfully fetched live exchange rate (er-api): {cls.USD_TO_INR}")
                     return cls.USD_TO_INR
         except Exception as e:
-            logger.error(f"Failed to fetch live exchange rate from Frankfurter: {e}")
+            logger.warning(f"Failed to fetch live exchange rate from ER-API: {e}")
 
+        # 2. Try ExchangeRate-API V4 (reliable, free fallback)
         try:
-            # Fallback: haxqer free api
-            response = requests.get("https://api.exchangerate.fun/latest", timeout=10)
+            response = requests.get("https://api.exchangerate-api.com/v4/latest/USD", timeout=5)
             if response.status_code == 200:
                 data = response.json()
                 rate = data.get("rates", {}).get("INR")
                 if rate:
                     cls.USD_TO_INR = float(rate)
-                    logger.info(f"Successfully fetched live exchange rate (fallback haxqer): {cls.USD_TO_INR}")
+                    logger.info(f"Successfully fetched live exchange rate (exchangerate-api): {cls.USD_TO_INR}")
                     return cls.USD_TO_INR
         except Exception as e:
-            logger.error(f"Failed to fetch live exchange rate from haxqer: {e}")
+            logger.warning(f"Failed to fetch live exchange rate from ExchangeRate-API: {e}")
 
+        # 3. Try Frankfurter API
+        try:
+            response = requests.get("https://api.frankfurter.app/latest?from=USD&to=INR", timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                rate = data.get("rates", {}).get("INR")
+                if rate:
+                    cls.USD_TO_INR = float(rate)
+                    logger.info(f"Successfully fetched live exchange rate (frankfurter): {cls.USD_TO_INR}")
+                    return cls.USD_TO_INR
+        except Exception as e:
+            logger.warning(f"Failed to fetch live exchange rate from Frankfurter: {e}")
+
+        logger.error(f"All live exchange rate APIs failed. Using fallback rate: {cls.USD_TO_INR}")
         return cls.USD_TO_INR
 
     @classmethod

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/server/models.py

@@ -1116,6 +1116,33 @@ MODEL_REGISTRY: dict[MODEL_ID, ModelEntry] = {
         capabilities=["chat", "code"],
         tags=["premium"],
     ),
+    "thinkingmachines/inkling": ModelEntry(
+        model_id="thinkingmachines/inkling",
+        provider="openrouter",
+        cost_input_per_1k=0.00105,
+        cost_output_per_1k=0.0042525,
+        context_window=1_048_576,
+        capabilities=["chat", "code"],
+        tags=["premium"],
+    ),
+    "moonshotai/kimi-k3": ModelEntry(
+        model_id="moonshotai/kimi-k3",
+        provider="openrouter",
+        cost_input_per_1k=0.00315,
+        cost_output_per_1k=0.01575,
+        context_window=1_000_000,
+        capabilities=["chat", "reasoning"],
+        tags=["premium", "reasoning"],
+    ),
+    "meta/muse-spark-1.1": ModelEntry(
+        model_id="meta/muse-spark-1.1",
+        provider="openrouter",
+        cost_input_per_1k=0.0013125,
+        cost_output_per_1k=0.0044625,
+        context_window=1_048_576,
+        capabilities=["chat", "code", "multimodal"],
+        tags=["premium", "multimodal"],
+    ),
 }
 
 # Default model used when the user does not specify one

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/server/pricing_updater.py

@@ -22,37 +22,55 @@ def fetch_and_update_pricing() -> bool:
             logger.error("No model data returned from OpenRouter")
             return False
         
-        # Create a map of model_id -> pricing
+        # Create a map of model_id -> data
         openrouter_models = {}
         for m in models_data:
             m_id = m.get("id")
             pricing = m.get("pricing")
-            if m_id and pricing:
-                openrouter_models[m_id] = pricing
+            context_length = m.get("context_length")
+            if m_id:
+                openrouter_models[m_id] = {
+                    "pricing": pricing,
+                    "context_length": context_length
+                }
                 
         updated_count = 0
         for model_id, entry in MODEL_REGISTRY.items():
+            if "free" in entry.tags:
+                entry.cost_input_per_1k = 0.0
+                entry.cost_output_per_1k = 0.0
+                continue
             if model_id in openrouter_models:
-                pricing = openrouter_models[model_id]
-                try:
-                    # prompt and completion are prices in USD per token
-                    prompt_str = pricing.get("prompt", "0.0")
-                    completion_str = pricing.get("completion", "0.0")
-                    
-                    prompt_usd = float(prompt_str)
-                    completion_usd = float(completion_str)
-                    
-                    # Convert to USD per 1M tokens (credits per 1K tokens) and add 2% markup fee
-                    cost_input = prompt_usd * 1_000_000 * 1.02
-                    cost_output = completion_usd * 1_000_000 * 1.02
-                    
-                    entry.cost_input_per_1k = cost_input
-                    entry.cost_output_per_1k = cost_output
-                    updated_count += 1
-                except Exception as e:
-                    logger.error(f"Error parsing pricing for model {model_id}: {e}")
+                m_data = openrouter_models[model_id]
+                pricing = m_data.get("pricing")
+                context_length = m_data.get("context_length")
+                
+                if context_length is not None:
+                    try:
+                        entry.context_window = int(context_length)
+                    except Exception as ce:
+                        logger.error(f"Error parsing context_length for {model_id}: {ce}")
+
+                if pricing:
+                    try:
+                        # prompt and completion are prices in USD per token
+                        prompt_str = pricing.get("prompt", "0.0")
+                        completion_str = pricing.get("completion", "0.0")
+                        
+                        prompt_usd = float(prompt_str)
+                        completion_usd = float(completion_str)
+                        
+                        # Convert to USD per 1M tokens (credits per 1K tokens) and add 5% markup fee
+                        cost_input = prompt_usd * 1_000_000 * 1.05
+                        cost_output = completion_usd * 1_000_000 * 1.05
+                        
+                        entry.cost_input_per_1k = cost_input
+                        entry.cost_output_per_1k = cost_output
+                        updated_count += 1
+                    except Exception as e:
+                        logger.error(f"Error parsing pricing for model {model_id}: {e}")
                     
-        logger.info(f"Successfully updated pricing for {updated_count} models (with 2% markup).")
+        logger.info(f"Successfully updated pricing for {updated_count} models (with 5% markup).")
         return True
     except Exception as e:
         logger.error(f"Error updating pricing from OpenRouter: {e}")

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/server/router.py

@@ -26,7 +26,7 @@ from .logging_config import configure_logging, RequestLoggingMiddleware
 from .rate_limit import limiter
 from slowapi import _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
-from .routes import auth_router, credit_router, session_router, completion_router, quota_router, share_router, feedback_router
+from .routes import auth_router, credit_router, session_router, completion_router, quota_router, share_router, feedback_router, referral_router
 from .models import list_models
 from .auth import get_admin_user
 
@@ -89,14 +89,14 @@ from fastapi.responses import JSONResponse
 class LimitUploadSize(BaseHTTPMiddleware):
     async def dispatch(self, request, call_next):
         if request.headers.get("content-length"):
-            if int(request.headers["content-length"]) > 25_000_000:  # 25MB limit
+            if int(request.headers["content-length"]) > 1_073_741_824:  # 1GB limit
                 # Consume stream to prevent abrupt connection closure / SSLEOFError on client
                 try:
                     async for _ in request.stream():
                         pass
                 except Exception:
                     pass
-                return JSONResponse({"detail": "Request too large (max 25MB)"}, status_code=413)
+                return JSONResponse({"detail": "Request too large (max 1GB)"}, status_code=413)
         return await call_next(request)
 
 app.add_middleware(LimitUploadSize)
@@ -112,6 +112,7 @@ app.include_router(completion_router)
 app.include_router(quota_router)
 app.include_router(share_router)
 app.include_router(feedback_router)
+app.include_router(referral_router)
 
 # ── Support Chatbot Endpoint ──────────────────────────────────────────────────
 
@@ -189,8 +190,9 @@ async def support_chat(request: Request, req: SupportChatRequest):
     import json
     ALLOWED_FREE_MODELS = {
         "poolside/laguna-xs.2:free",
-        "google/gemma-2-9b-it:free",
         "cohere/north-mini-code:free",
+        "google/gemma-4-31b-it:free",
+        "google/gemma-4-26b-a4b-it:free",
         "openrouter/free"
     }
     
@@ -210,7 +212,7 @@ async def support_chat(request: Request, req: SupportChatRequest):
 
     # Generate candidate models starting with the requested one
     candidate_models = [model_name]
-    for fallback in ["openrouter/free", "google/gemma-2-9b-it:free", "cohere/north-mini-code:free", "poolside/laguna-xs.2:free"]:
+    for fallback in ["openrouter/free", "cohere/north-mini-code:free", "google/gemma-4-31b-it:free", "poolside/laguna-xs.2:free"]:
         if fallback not in candidate_models:
             candidate_models.append(fallback)
 

{utim_cli-1.47.0 → utim_cli-1.47.2}/utim_cli/server/routes/__init__.py

@@ -5,6 +5,7 @@ from .completion_routes import router as completion_router
 from .quota_routes import router as quota_router
 from .share_routes import router as share_router
 from .feedback_routes import router as feedback_router
+from .referral_routes import router as referral_router
 
-__all__ = ["auth_router", "credit_router", "session_router", "completion_router", "quota_router", "share_router", "feedback_router"]
+__all__ = ["auth_router", "credit_router", "session_router", "completion_router", "quota_router", "share_router", "feedback_router", "referral_router"]