@agxnte/reidx 2.0.5 → 2.0.7

package/package.json

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

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reidx"
-version = "2.0.5"
+version = "2.0.6"
 description = "Terminal-native personal intelligence and coding CLI (agent-first runtime)"
 readme = "README.md"
 requires-python = ">=3.12"

package/src/reidx/__init__.py

@@ -1,3 +1,3 @@
 """ReidX: terminal-native agent-first CLI runtime."""
 
-__version__ = "2.0.5"
+__version__ = "2.0.6"

package/src/reidx/provider/_http.py

@@ -1,42 +1,75 @@
-"""Shared HTTP helper for provider clients — stdlib urllib, no extra deps."""
-from __future__ import annotations
-
-import json
-import urllib.error
-import urllib.request
-
-TIMEOUT_SECONDS = 120
-
-
-def post_json(url: str, payload: dict, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
-    """POST a JSON payload, return the parsed JSON response.
-
-    Raises RuntimeError on HTTP or network errors — providers surface those
-    to the agent loop, which turns them into tool-result errors rather than
-    crashing the turn.
-    """
-    body = json.dumps(payload).encode("utf-8")
-    hdrs = {"content-type": "application/json", **headers}
-    req = urllib.request.Request(url, data=body, headers=hdrs, method="POST")
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8")
-    except urllib.error.HTTPError as exc:
-        err_body = exc.read().decode("utf-8", errors="replace")[:500]
-        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
-    except urllib.error.URLError as exc:
-        raise RuntimeError(f"connection error: {exc}") from exc
-    return json.loads(raw)
-
-
-def get_json(url: str, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
-    req = urllib.request.Request(url, headers=headers, method="GET")
-    try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
-            raw = resp.read().decode("utf-8")
-    except urllib.error.HTTPError as exc:
-        err_body = exc.read().decode("utf-8", errors="replace")[:500]
-        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
-    except urllib.error.URLError as exc:
-        raise RuntimeError(f"connection error: {exc}") from exc
-    return json.loads(raw)
+"""Shared HTTP helper for provider clients — stdlib urllib, no extra deps."""
+from __future__ import annotations
+
+import json
+import os
+import ssl
+import urllib.error
+import urllib.request
+
+TIMEOUT_SECONDS = 120
+
+_SSL_CONTEXT: ssl.SSLContext | None = None
+
+
+def _build_ssl_context() -> ssl.SSLContext:
+    insecure = os.environ.get("REIDX_INSECURE", "").strip().lower() in ("1", "true", "yes", "on")
+    if insecure:
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+
+    try:
+        import certifi
+        return ssl.create_default_context(cafile=certifi.where())
+    except ImportError:
+        pass
+
+    ctx = ssl.create_default_context()
+    try:
+        ctx.load_default_certs(ssl.Purpose.SERVER_AUTH)
+    except ssl.SSLError:
+        pass
+    return ctx
+
+
+def _ssl_ctx() -> ssl.SSLContext:
+    global _SSL_CONTEXT
+    if _SSL_CONTEXT is None:
+        _SSL_CONTEXT = _build_ssl_context()
+    return _SSL_CONTEXT
+
+
+def post_json(url: str, payload: dict, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
+    """POST a JSON payload, return the parsed JSON response.
+
+    Raises RuntimeError on HTTP or network errors — providers surface those
+    to the agent loop, which turns them into tool-result errors rather than
+    crashing the turn.
+    """
+    body = json.dumps(payload).encode("utf-8")
+    hdrs = {"content-type": "application/json", **headers}
+    req = urllib.request.Request(url, data=body, headers=hdrs, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_ctx()) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", errors="replace")[:500]
+        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"connection error: {exc}") from exc
+    return json.loads(raw)
+
+
+def get_json(url: str, headers: dict[str, str], timeout: int = TIMEOUT_SECONDS) -> dict:
+    req = urllib.request.Request(url, headers=headers, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout, context=_ssl_ctx()) as resp:
+            raw = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", errors="replace")[:500]
+        raise RuntimeError(f"HTTP {exc.code}: {err_body}") from exc
+    except urllib.error.URLError as exc:
+        raise RuntimeError(f"connection error: {exc}") from exc
+    return json.loads(raw)

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
@@ -127,7 +132,10 @@ class ProviderStore:
         return True
 
 
-def validate_provider(record: ProviderRecord) -> tuple[bool, str]:
+def validate_provider(
+    record: ProviderRecord,
+    skip_verify: bool = False,
+) -> tuple[bool, str]:
     try:
         provider = build_provider(record)
     except (ValueError, TypeError) as exc:
@@ -137,15 +145,32 @@ def validate_provider(record: ProviderRecord) -> tuple[bool, str]:
         return False, "API key required for this provider kind"
     if not record.api_key:
         return True, "no key required"
+    if skip_verify:
+        return True, "verification skipped"
     try:
         models = provider.fetch_models()
+    except RuntimeError as exc:
+        msg = str(exc)
+        if msg.startswith("HTTP 401") or msg.startswith("HTTP 403"):
+            return False, f"authentication failed ({msg})"
+        if msg.startswith("HTTP "):
+            return False, f"provider error: {msg}"
+        return False, f"{msg} (use --skip-verify to save anyway)"
     except Exception as exc:
-        return False, f"could not connect to provider: {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)"
-    if record.kind == "ollama":
-        return True, "connected"
-    return False, "key rejected or no models returned"
+    return True, "connected (no models endpoint or empty list)"
 
 
 def load_into(registry: ProviderRegistry, storage_root: Path) -> list[str]:
@@ -162,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)
@@ -188,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
@@ -610,8 +624,14 @@ class ProviderPalette:
             )
             ok, msg = validate_provider(record)
             if not ok:
-                self._show_message(f"Key validation failed: {msg}", self.WIZARD)
-                self.wizard_step_idx = len(WIZARD_STEPS) - 1
+                self._confirm_text = f"Key validation failed: {msg}\nSave anyway?"
+                self._pending_action = lambda: self._commit_wizard_provider(
+                    name, kind, base_url, model, auth, api_key, forced_msg=msg,
+                )
+                self.screen = self.CONFIRM
+                self.selected_index = 0
+                self._scroll_offset = 0
+                self._invalidate()
                 return
             if not model:
                 try:
@@ -620,8 +640,22 @@ 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)
 
+    def _commit_wizard_provider(
+        self,
+        name: str,
+        kind: str,
+        base_url: str,
+        model: str,
+        auth: str,
+        api_key: str,
+        forced_msg: str = "",
+    ) -> str:
         existing = self.db.get_provider(name)
         if existing:
             existing.kind = kind
@@ -660,7 +694,9 @@ class ProviderPalette:
         self.wizard_data = {}
         self.wizard_step_idx = 0
         self.input_is_password = False
-        self._close(f"Saved provider '{name}' ({kind})")
+        note = " (unverified)" if forced_msg else ""
+        self._close(f"Saved provider '{name}' ({kind}){note}")
+        return f"Saved provider '{name}'"
 
     def _do_add_key(self, label: str, api_key: str) -> None:
         if not self.current_provider:
@@ -673,13 +709,25 @@ class ProviderPalette:
             auth_method=sp.auth_method,
         )
         ok, msg = validate_provider(record)
-        if not ok:
-            self._show_message(f"Key validation failed: {msg}", self.MANAGE)
+        if ok:
+            self._commit_key(label, api_key, msg)
             return
+        self._confirm_text = f"Key validation failed: {msg}\nSave anyway?"
+        self._pending_action = lambda: self._commit_key(label, api_key, "saved (unverified)")
+        self.screen = self.CONFIRM
+        self.selected_index = 0
+        self._scroll_offset = 0
+        self._invalidate()
+
+    def _commit_key(self, label: str, api_key: str, msg: str) -> str:
+        if not self.current_provider:
+            return "Error: no provider"
+        name = self.current_provider.name
         self.db.add_key(name, label, api_key)
         self.current_provider = self.db.get_provider(name)
         self._register_current()
         self._show_message(f"Added key '{label}' ({msg})", self.MANAGE)
+        return f"Added key '{label}'"
 
     def _do_delete_key(self, key_id: str, label: str) -> str:
         if not self.current_provider:
@@ -718,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)
 
 
@@ -536,10 +548,17 @@ def _handle_providers(orchestrator: Orchestrator) -> None:
 
 
 def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
-    parts = arg.split()
+    skip_verify = False
+    tokens = arg.split()
+    parts: list[str] = []
+    for tok in tokens:
+        if tok in ("--skip-verify", "--skip", "--no-verify"):
+            skip_verify = True
+        else:
+            parts.append(tok)
     if len(parts) < 3:
         render.print_error(
-            "usage: /connect <name> <kind> <base_url> [api_key] [model]  "
+            "usage: /connect <name> <kind> <base_url> [api_key] [model] [--skip-verify]  "
             f"(kind: {'|'.join(SUPPORTED_KINDS)})"
         )
         return
@@ -554,7 +573,7 @@ def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
     model = parts[4] if len(parts) > 4 else ""
     record = ProviderRecord(name=name, kind=kind, base_url=base_url, api_key=api_key, default_model=model)
     if api_key:
-        ok, msg = validate_provider(record)
+        ok, msg = validate_provider(record, skip_verify=skip_verify)
         if not ok:
             render.print_error(f"key validation failed: {msg}")
             return
@@ -564,21 +583,24 @@ def _handle_connect(orchestrator: Orchestrator, arg: str) -> None:
     except ValueError as exc:
         render.print_error(f"failed to build provider: {exc}")
         return
-    if not model and api_key:
+    if not model and api_key and not skip_verify:
         try:
             models = provider.fetch_models()
         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: