@agxnte/reidx 2.0.6 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agxnte/reidx",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Terminal-native personal intelligence and coding CLI (agent-first runtime)",
   "bin": {
     "reid": "bin/reidx.js"

package/src/reidx/provider/models.py

@@ -0,0 +1,229 @@
+"""Model normalization, validation, and discovery utilities."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+from reidx.diagnostics.logger import get_logger
+
+log = get_logger("reidx.provider.models")
+
+KNOWN_PROVIDER_PREFIXES = {
+    "openrouter",
+    "anthropic",
+    "openai",
+    "google",
+    "cohere",
+    "mistral",
+    "meta",
+    "meta-llama",
+    "microsoft",
+    "nvidia",
+    "deepseek",
+    "qwen",
+    "yi",
+    "zai",
+    "xai",
+    "perplexity",
+    "together",
+    "fireworks",
+    "groq",
+    "cerebras",
+    "deepinfra",
+    "sambanova",
+    "novita",
+    "featherless",
+    "chutes",
+    "aimlapi",
+    "hyperbolic",
+    "moonshot",
+    "volcengine",
+    "hunyuan",
+    "upstage",
+    "predibase",
+    "gravity",
+    "infermatic",
+    "baseten",
+    "anyscale",
+    "lambda",
+    "kluster",
+    "monsterapi",
+    "cloudflare-ai",
+    "replicate",
+    "watsonx",
+    "aleph-alpha",
+    "ai21",
+    "databricks",
+    "siliconflow",
+    "nebius",
+    "lepton",
+    "voyage-ai",
+    "jan",
+    "llamacpp",
+}
+
+VALID_VARIANTS = {":free", ":thinking", ":nitro", ":extended", ":online", ":alpha", ":beta"}
+VALID_VARIANTS_LOWER = {v.lower() for v in VALID_VARIANTS}
+
+UI_DISPLAY_PATTERN = re.compile(r"\s*\[via\s+([^\]]+)\]", re.IGNORECASE)
+PROVIDER_DASH_PATTERN = re.compile(r"^([A-Za-z0-9\-]+)\s+-\s+(.+)$")
+
+
+@dataclass(frozen=True)
+class NormalizedModel:
+    provider: str
+    model_id: str
+    full_id: str
+    variant: Optional[str]
+    base_model: str
+    is_valid: bool
+
+
+def normalize_model_id(raw: str, provider_name: Optional[str] = None) -> NormalizedModel:
+    original = raw.strip()
+
+    # Remove UI display text like "[via openrouter]"
+    cleaned = UI_DISPLAY_PATTERN.sub("", original).strip()
+
+    # Remove "ProviderName - " prefix
+    dash_match = PROVIDER_DASH_PATTERN.match(cleaned)
+    if dash_match:
+        cleaned = dash_match.group(2).strip()
+
+    parts = cleaned.split("/")
+
+    if not parts or not parts[0]:
+        return NormalizedModel(
+            provider=provider_name.lower() if provider_name else "",
+            model_id=cleaned,
+            full_id=cleaned,
+            variant=None,
+            base_model=cleaned,
+            is_valid=False,
+        )
+
+    first_part_lower = parts[0].lower()
+    provider = ""
+    model_parts = parts
+
+    if provider_name and provider_name.lower() in KNOWN_PROVIDER_PREFIXES:
+        provider = provider_name.lower()
+        if first_part_lower == provider:
+            model_parts = parts[1:]
+    elif first_part_lower in KNOWN_PROVIDER_PREFIXES:
+        provider = first_part_lower
+        model_parts = parts[1:]
+
+    if not model_parts:
+        return NormalizedModel(
+            provider=provider,
+            model_id="",
+            full_id=cleaned,
+            variant=None,
+            base_model="",
+            is_valid=False,
+        )
+
+    model_id = "/".join(model_parts)
+
+    variant = None
+    base_model = model_id
+    for v in VALID_VARIANTS:
+        if model_id.lower().endswith(v.lower()):
+            variant = v[1:]
+            base_model = model_id[: -len(v)]
+            break
+
+    if provider:
+        full_id = f"{provider}/{model_id}"
+    else:
+        full_id = model_id
+
+    is_valid = bool(provider and base_model and "/" in base_model)
+
+    return NormalizedModel(
+        provider=provider,
+        model_id=model_id,
+        full_id=full_id,
+        variant=variant,
+        base_model=base_model,
+        is_valid=is_valid,
+    )
+
+
+def denormalize_model_id(normalized: NormalizedModel, include_provider: bool = True) -> str:
+    if include_provider and normalized.provider:
+        return normalized.full_id
+    return normalized.model_id
+
+
+async def fetch_provider_models(provider) -> list[str]:
+    import asyncio
+    try:
+        loop = asyncio.get_event_loop()
+        models = await loop.run_in_executor(None, provider.fetch_models)
+        return sorted(models) if models else []
+    except Exception as exc:
+        log.warning("failed to fetch models from provider: %s", exc)
+        return []
+
+
+def validate_model_against_provider(
+    normalized: NormalizedModel,
+    available_models: list[str],
+) -> tuple[bool, str]:
+    if not normalized.is_valid:
+        return False, f"Invalid model format: {normalized.full_id}"
+
+    if not available_models:
+        return True, "No model list available from provider (skipping validation)"
+
+    if normalized.full_id in available_models:
+        return True, "Model found in provider catalog"
+
+    if normalized.model_id in available_models:
+        return True, "Model found in provider catalog (without provider prefix)"
+
+    if normalized.base_model in available_models:
+        return True, f"Base model found (variant '{normalized.variant}' may not be listed separately)"
+
+    base_with_provider = f"{normalized.provider}/{normalized.base_model}"
+    if base_with_provider in available_models:
+        return True, f"Base model found with provider prefix (variant '{normalized.variant}' may not be listed separately)"
+
+    for avail in available_models:
+        if normalized.base_model in avail or avail in normalized.base_model:
+            return True, f"Similar model found: {avail}"
+
+    return False, f"Model '{normalized.full_id}' not found in provider catalog ({len(available_models)} models available)"
+
+
+class ModelCache:
+    def __init__(self) -> None:
+        self._cache: dict[str, tuple[list[str], float]] = {}
+        self._ttl = 3600
+
+    def get(self, provider_name: str) -> Optional[list[str]]:
+        import time
+        if provider_name in self._cache:
+            models, timestamp = self._cache[provider_name]
+            if time.time() - timestamp < self._ttl:
+                return models
+            else:
+                del self._cache[provider_name]
+        return None
+
+    def set(self, provider_name: str, models: list[str]) -> None:
+        import time
+        self._cache[provider_name] = (models, time.time())
+
+    def invalidate(self, provider_name: str) -> None:
+        self._cache.pop(provider_name, None)
+
+
+_model_cache = ModelCache()
+
+
+def get_model_cache() -> ModelCache:
+    return _model_cache

package/src/reidx/provider/store.py

@@ -23,6 +23,11 @@ from pathlib import Path
 from reidx.diagnostics.logger import get_logger
 from reidx.provider.anthropic import AnthropicProvider
 from reidx.provider.base import BaseProvider
+from reidx.provider.models import (
+    denormalize_model_id,
+    normalize_model_id,
+    validate_model_against_provider,
+)
 from reidx.provider.ollama import OllamaProvider
 from reidx.provider.openai import OpenAICompatibleProvider, OpenAIProvider
 from reidx.provider.registry import ProviderRegistry
@@ -153,6 +158,16 @@ def validate_provider(
         return False, f"{msg} (use --skip-verify to save anyway)"
     except Exception as exc:
         return False, f"unexpected error: {exc} (use --skip-verify to save anyway)"
+    
+    if models and record.default_model:
+        normalized = normalize_model_id(record.default_model, provider_name=record.name)
+        if normalized.is_valid:
+            is_valid, msg = validate_model_against_provider(normalized, models)
+            if not is_valid:
+                return False, f"model validation failed: {msg}"
+            # Update the record with the normalized model ID
+            record.default_model = denormalize_model_id(normalized)
+    
     if models:
         return True, f"ok ({len(models)} models available)"
     return True, "connected (no models endpoint or empty list)"
@@ -172,6 +187,7 @@ def load_into(registry: ProviderRegistry, storage_root: Path) -> list[str]:
 
 def load_from_database(registry: ProviderRegistry, storage_root: Path) -> list[str]:
     from reidx.provider_manager.database import ProviderDatabase
+    from reidx.provider.models import denormalize_model_id, normalize_model_id
 
     added: list[str] = []
     db = ProviderDatabase(storage_root)
@@ -198,10 +214,22 @@ def load_from_database(registry: ProviderRegistry, storage_root: Path) -> list[s
             except Exception:
                 models = []
             if models:
-                provider.default_model = models[0]
-                sp.default_model = models[0]
+                normalized = normalize_model_id(models[0], provider_name=sp.name)
+                if normalized.is_valid:
+                    model = denormalize_model_id(normalized)
+                    provider.default_model = model
+                    sp.default_model = model
+                    db.save_provider(sp)
+                    log.info("auto-fetched model for %s: %s", sp.name, model)
+        elif record.default_model:
+            # Normalize the existing model
+            normalized = normalize_model_id(record.default_model, provider_name=sp.name)
+            if normalized.is_valid:
+                model = denormalize_model_id(normalized)
+                record.default_model = model
+                provider.default_model = model
+                sp.default_model = model
                 db.save_provider(sp)
-                log.info("auto-fetched model for %s: %s", sp.name, models[0])
         registry.register(sp.name, provider)
         added.append(sp.name)
     return added

package/src/reidx/provider_manager/palette.py

@@ -9,6 +9,14 @@ from typing import Any
 from prompt_toolkit.buffer import Buffer
 
 from reidx.diagnostics.logger import get_logger
+from reidx.provider.models import (
+    ModelCache,
+    NormalizedModel,
+    denormalize_model_id,
+    fetch_provider_models,
+    normalize_model_id,
+    validate_model_against_provider,
+)
 from reidx.provider.store import ProviderRecord, build_provider, validate_provider
 from reidx.provider_manager.catalog import (
     ProviderDefinition,
@@ -267,6 +275,12 @@ class ProviderPalette:
             self._handle_input_enter()
             self._invalidate()
             return
+        if self.screen == self.MESSAGE:
+            self.screen = self._message_next
+            self.selected_index = 0
+            self._scroll_offset = 0
+            self._invalidate()
+            return
         items = self._build_items()
         if not items:
             return
@@ -626,7 +640,9 @@ class ProviderPalette:
                 except Exception:
                     models = []
                 if models:
-                    model = models[0]
+                    normalized = normalize_model_id(models[0], provider_name=name)
+                    if normalized.is_valid:
+                        model = denormalize_model_id(normalized)
 
         self._commit_wizard_provider(name, kind, base_url, model, auth, api_key)
 
@@ -750,9 +766,11 @@ class ProviderPalette:
                 except Exception:
                     models = []
                 if models:
-                    provider.default_model = models[0]
-                    sp.default_model = models[0]
-                    self.db.save_provider(sp)
+                    normalized = normalize_model_id(models[0], provider_name=sp.name)
+                    if normalized.is_valid:
+                        provider.default_model = denormalize_model_id(normalized)
+                        sp.default_model = denormalize_model_id(normalized)
+                        self.db.save_provider(sp)
             self.orchestrator.providers.register(sp.name, provider)
         except (ValueError, TypeError):
             log.exception("failed to register provider %s", sp.name)

package/src/reidx/ui/commands.py

@@ -19,6 +19,7 @@ from rich.text import Text
 from reidx.config.storage import storage_root
 from reidx.goals.models import Goal, GoalNodeKind, GoalStatus
 from reidx.policy.models import PermissionMode
+from reidx.provider.models import denormalize_model_id, normalize_model_id
 from reidx.provider.store import (
     SUPPORTED_KINDS,
     ProviderRecord,
@@ -486,6 +487,7 @@ def _providers_store(orchestrator: Orchestrator) -> ProviderStore:
 def _save_to_database(orchestrator: Orchestrator, record: ProviderRecord) -> None:
     from reidx.provider_manager import keychain
     from reidx.provider_manager.database import ProviderDatabase, StoredKey, StoredProvider
+    from reidx.provider.models import denormalize_model_id, normalize_model_id
 
     root = orchestrator.config.storage_root or storage_root()
     db = ProviderDatabase(root)
@@ -504,7 +506,11 @@ def _save_to_database(orchestrator: Orchestrator, record: ProviderRecord) -> Non
         existing.base_url = record.base_url
         existing.auth_method = record.auth_method
         if record.default_model:
-            existing.default_model = record.default_model
+            normalized = normalize_model_id(record.default_model, provider_name=record.name)
+            if normalized.is_valid:
+                existing.default_model = denormalize_model_id(normalized)
+            else:
+                existing.default_model = record.default_model
         db.save_provider(existing)
     else:
         sp = StoredProvider(
@@ -519,6 +525,12 @@ def _save_to_database(orchestrator: Orchestrator, record: ProviderRecord) -> Non
             )
             sp.keys.append(k)
             sp.active_key_id = k.id
+        if record.default_model:
+            normalized = normalize_model_id(record.default_model, provider_name=record.name)
+            if normalized.is_valid:
+                sp.default_model = denormalize_model_id(normalized)
+            else:
+                sp.default_model = record.default_model
         db.save_provider(sp)
 
 
@@ -577,15 +589,18 @@ def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
         except Exception:
             models = []
         if models:
-            provider.default_model = models[0]
-            record.default_model = models[0]
-            render.print_info(f"auto-detected model: {models[0]}")
+            normalized = normalize_model_id(models[0], provider_name=name)
+            if normalized.is_valid:
+                model = denormalize_model_id(normalized)
+                provider.default_model = model
+                record.default_model = model
+                render.print_info(f"auto-detected model: {model}")
     _providers_store(orchestrator).save(record)
     _save_to_database(orchestrator, record)
     if orchestrator.providers is not None:
         orchestrator.providers.register(name, provider)
-    render.print_info(f"connected provider '{name}' ({kind}) → {base_url or '(default)'}")
-    render.print_info(f"switch with: /use {name}")
+    render.print_info(f"connected provider '{name}' ({kind})  {base_url or '(default)'}")
+    render.print_info(f"switch with: /use {name}")
 
 
 def _handle_disconnect(orchestrator: Orchestrator, arg: str) -> None: