thwip-cli 1.0.2__tar.gz → 1.0.4__tar.gz

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thwip-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly
 Project-URL: Homepage, https://github.com/tanmayhutt/thwip-cli
 Project-URL: Repository, https://github.com/tanmayhutt/thwip-cli

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thwip-cli"
-version = "1.0.2"
+version = "1.0.4"
 description = "Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly"
 readme = "README.md"
 license = "MIT"

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/__init__.py

@@ -1,4 +1,4 @@
 """thwip: Universal Coding Agent Multiplexer."""
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"
 __app_name__ = "thwip"

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/agents/base.py

@@ -158,6 +158,8 @@ class ModelInfo:
     """Information about a specific model."""
     id: str                     # "claude-sonnet-4"
     name: str                   # "Claude Sonnet 4"
+    tier: str = "balanced"      # "flagship" (high), "balanced" (mid), "fast" (low-cost)
+    description: str = ""       # e.g. "Flagship reasoning with 1M context"
     context_window: int = 0     # Max tokens
     max_output: int = 0         # Max output tokens
     supports_tools: bool = True
@@ -208,9 +210,22 @@ class BaseAgent(ABC):
 
     @abstractmethod
     def is_configured(self) -> bool:
-        """Check if this agent has a valid API key / credentials."""
+        """Check if this agent has a valid API key or OAuth/subscription credentials."""
         ...
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """
+        Check if the agent's CLI tool has its own OAuth/subscription auth.
+        Returns dict with 'method' and 'account' keys if found, else None.
+        Subclasses should override this.
+        """
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        """Return the auth method in use: 'api_key', 'oauth', 'subscription', or 'none'."""
+        return "none"
+
     @abstractmethod
     def get_install_info(self) -> dict[str, str]:
         """
@@ -303,6 +318,15 @@ class BaseAgent(ABC):
         if not self.is_configured():
             return ("Installed (No Key)", "status.limited")
 
+        # Show auth method in status for non-API-key auth
+        auth = self.auth_method
+        if auth in ("oauth", "subscription"):
+            cli_auth = self._has_cli_auth()
+            account = cli_auth.get("account", "") if cli_auth else ""
+            if account:
+                return (f"Ready ({account})", "status.ready")
+            return ("Ready (CLI Auth)", "status.ready")
+
         limit = self.check_limits()
         if limit == LimitStatus.OK:
             return ("Ready", "status.ready")

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/agents/claude_agent.py

@@ -59,6 +59,8 @@ class ClaudeAgent(BaseAgent):
         ModelInfo(
             id="claude-sonnet-4",
             name="Claude Sonnet 4",
+            tier="flagship",
+            description="Flagship coding intelligence with hybrid thinking and tool precision",
             context_window=200_000,
             max_output=16_384,
             supports_tools=True,
@@ -72,6 +74,8 @@ class ClaudeAgent(BaseAgent):
         ModelInfo(
             id="claude-opus-4",
             name="Claude Opus 4",
+            tier="flagship",
+            description="Ultra high capability reasoning for complex systems engineering",
             context_window=200_000,
             max_output=32_000,
             supports_tools=True,
@@ -84,6 +88,8 @@ class ClaudeAgent(BaseAgent):
         ModelInfo(
             id="claude-haiku-3.5",
             name="Claude Haiku 3.5",
+            tier="fast",
+            description="Fastest lightweight Claude model for rapid iteration",
             context_window=200_000,
             max_output=8_192,
             supports_tools=True,
@@ -149,7 +155,11 @@ class ClaudeAgent(BaseAgent):
     # --- Detection ---
 
     def is_installed(self) -> bool:
-        """Check if Claude Code CLI or Claude desktop app is installed or configured."""
+        """Check if Claude Code CLI or Claude desktop app is installed.
+
+        The ~/.claude directory alone is not sufficient since other IDEs
+        (like Antigravity) may create it.
+        """
         if self.is_configured():
             return True
         if shutil.which("claude") is not None:
@@ -157,13 +167,50 @@ class ClaudeAgent(BaseAgent):
         app_paths = [
             Path("/Applications/Claude.app"),
             Path.home() / "Applications" / "Claude.app",
-            Path.home() / ".claude",
         ]
         return any(p.exists() for p in app_paths)
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """Check for Claude Code subscription auth.
+
+        Requires the `claude` CLI binary or Claude.app to be present.
+        The ~/.claude directory alone is not sufficient since other IDEs
+        (like Antigravity) may create it.
+        """
+        has_cli = shutil.which("claude") is not None
+        has_app = Path("/Applications/Claude.app").exists() or (Path.home() / "Applications" / "Claude.app").exists()
+
+        if not has_cli and not has_app:
+            return None
+
+        claude_dir = Path.home() / ".claude"
+        if not claude_dir.is_dir():
+            return None
+
+        # Claude Code stores session data when authenticated
+        auth_indicators = [
+            claude_dir / "projects",
+            claude_dir / "backups",
+            claude_dir / "debug",
+        ]
+        has_sessions = any(p.is_dir() and any(p.iterdir()) for p in auth_indicators if p.exists())
+
+        if has_sessions:
+            return {"method": "subscription", "account": "Anthropic Max"}
+
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        if self._get_api_key():
+            return "api_key"
+        if self._has_cli_auth():
+            return "subscription"
+        return "none"
+
     def is_configured(self) -> bool:
-        """Check if we have a valid Anthropic API key."""
-        return bool(self._get_api_key())
+        """Check if we have a valid API key or subscription auth."""
+        return bool(self._get_api_key()) or bool(self._has_cli_auth())
 
     def get_install_info(self) -> dict[str, str]:
         """Get Claude Code installation details."""
@@ -192,7 +239,6 @@ class ClaudeAgent(BaseAgent):
             app_paths = [
                 Path("/Applications/Claude.app"),
                 Path.home() / "Applications" / "Claude.app",
-                Path.home() / ".claude",
             ]
             for app in app_paths:
                 if app.exists():
@@ -207,29 +253,35 @@ class ClaudeAgent(BaseAgent):
     def get_subscription_info(self) -> SubscriptionInfo:
         """
         Determine subscription status.
-        We can't fully detect tier without an API call, but we can infer from
-        the key prefix and check basic validity.
+        Checks API key first, then CLI subscription auth.
         """
         key = self._get_api_key()
-        if not key:
+        if key:
+            if key.startswith("sk-ant-"):
+                return SubscriptionInfo(
+                    tier=SubscriptionTier.PRO,
+                    is_active=True,
+                    message="Anthropic API key detected",
+                )
             return SubscriptionInfo(
                 tier=SubscriptionTier.UNKNOWN,
-                is_active=False,
-                message="No API key found",
+                is_active=True,
+                message="API key detected",
             )
 
-        # Anthropic keys start with "sk-ant-"
-        if key.startswith("sk-ant-"):
+        cli_auth = self._has_cli_auth()
+        if cli_auth:
+            account = cli_auth.get("account", "Active")
             return SubscriptionInfo(
-                tier=SubscriptionTier.PRO,  # Assume pro if they have a key
+                tier=SubscriptionTier.PRO,
                 is_active=True,
-                message="API key detected",
+                message=f"Claude Code ({account})",
             )
 
         return SubscriptionInfo(
             tier=SubscriptionTier.UNKNOWN,
-            is_active=True,
-            message="API key format not recognized, but may work",
+            is_active=False,
+            message="No credentials found",
         )
 
     # --- Chat ---

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/agents/google_agent.py

@@ -59,6 +59,8 @@ class GoogleAgent(BaseAgent):
         ModelInfo(
             id="gemini-2.5-pro",
             name="Gemini 2.5 Pro",
+            tier="flagship",
+            description="Flagship multimodal model with 1M context and advanced reasoning",
             context_window=1_048_576,
             max_output=65_536,
             supports_tools=True,
@@ -72,6 +74,8 @@ class GoogleAgent(BaseAgent):
         ModelInfo(
             id="gemini-2.5-flash",
             name="Gemini 2.5 Flash",
+            tier="balanced",
+            description="High-speed balanced model optimized for daily coding workflows",
             context_window=1_048_576,
             max_output=65_536,
             supports_tools=True,
@@ -81,6 +85,20 @@ class GoogleAgent(BaseAgent):
             pricing_input=0.15,
             pricing_output=0.60,
         ),
+        ModelInfo(
+            id="gemini-2.5-flash-lite",
+            name="Gemini 2.5 Flash Lite",
+            tier="fast",
+            description="Ultra lightweight and cost-effective model for rapid tasks",
+            context_window=1_048_576,
+            max_output=65_536,
+            supports_tools=True,
+            supports_streaming=True,
+            supports_vision=False,
+            supports_thinking=False,
+            pricing_input=0.075,
+            pricing_output=0.30,
+        ),
     ]
 
     def __init__(self, api_key: str | None = None) -> None:
@@ -149,8 +167,31 @@ class GoogleAgent(BaseAgent):
         ]
         return any(p.exists() for p in app_paths)
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """Check for Google OAuth via Gemini CLI's google_accounts.json."""
+        acc_file = Path.home() / ".gemini" / "google_accounts.json"
+        if acc_file.is_file():
+            try:
+                data = json.loads(acc_file.read_text())
+                account = data.get("active") or ""
+                if not account and data.get("old"):
+                    account = data["old"][0]
+                if account:
+                    return {"method": "google_oauth", "account": account}
+            except Exception:
+                pass
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        if self._get_api_key():
+            return "api_key"
+        if self._has_cli_auth():
+            return "oauth"
+        return "none"
+
     def is_configured(self) -> bool:
-        return bool(self._get_api_key())
+        return bool(self._get_api_key()) or bool(self._has_cli_auth())
 
     def get_install_info(self) -> dict[str, str]:
         info: dict[str, str] = {"method": "not installed", "path": "", "version": ""}
@@ -171,7 +212,7 @@ class GoogleAgent(BaseAgent):
                     pass
                 break
 
-        # Also check for Antigravity IDE or Gemini app (macOS app)
+        # Check for Antigravity IDE or Gemini app (macOS app)
         if not info["path"]:
             app_paths = [
                 Path("/Applications/Antigravity IDE.app"),
@@ -187,29 +228,47 @@ class GoogleAgent(BaseAgent):
                     info["version"] = "Installed"
                     break
 
+        # Check for Google Account in ~/.gemini/google_accounts.json
+        acc_file = Path.home() / ".gemini" / "google_accounts.json"
+        if acc_file.is_file():
+            try:
+                acc_data = json.loads(acc_file.read_text())
+                account = acc_data.get("active") or (acc_data.get("old") and acc_data["old"][0]) or ""
+                if account:
+                    info["account"] = account
+            except Exception:
+                pass
+
         return info
 
     def get_subscription_info(self) -> SubscriptionInfo:
         key = self._get_api_key()
-        if not key:
+        if key:
+            if key.startswith("AIza"):
+                return SubscriptionInfo(
+                    tier=SubscriptionTier.FREE,
+                    is_active=True,
+                    message="Google API key detected",
+                )
             return SubscriptionInfo(
                 tier=SubscriptionTier.UNKNOWN,
-                is_active=False,
-                message="No API key found",
+                is_active=True,
+                message="API key detected",
             )
 
-        # Google Gemini API keys typically start with "AIza"
-        if key.startswith("AIza"):
+        cli_auth = self._has_cli_auth()
+        if cli_auth:
+            account = cli_auth.get("account", "")
             return SubscriptionInfo(
-                tier=SubscriptionTier.FREE,  # Free tier by default
+                tier=SubscriptionTier.PRO,
                 is_active=True,
-                message="Google API key detected",
+                message=f"Google OAuth ({account})" if account else "Google OAuth active",
             )
 
         return SubscriptionInfo(
             tier=SubscriptionTier.UNKNOWN,
-            is_active=True,
-            message="API key detected",
+            is_active=False,
+            message="No credentials found",
         )
 
     # --- Chat ---

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/agents/openai_agent.py

@@ -40,9 +40,9 @@ class OpenAIAgent(BaseAgent):
     """
 
     name = "openai"
-    display_name = "Codex / OpenAI"
+    display_name = "ChatGPT / Codex"
     company = "OpenAI"
-    description = "OpenAI's coding agent with sandboxed code execution"
+    description = "OpenAI's ChatGPT and Codex models with tool execution"
     website = "https://platform.openai.com"
 
     capabilities = {
@@ -59,6 +59,8 @@ class OpenAIAgent(BaseAgent):
         ModelInfo(
             id="gpt-4.1",
             name="GPT-4.1",
+            tier="flagship",
+            description="Next-generation flagship with 1M context and advanced coding",
             context_window=1_047_576,
             max_output=32_768,
             supports_tools=True,
@@ -71,6 +73,8 @@ class OpenAIAgent(BaseAgent):
         ModelInfo(
             id="o3",
             name="O3",
+            tier="flagship",
+            description="Deep reasoning model with autonomous multi-step problem solving",
             context_window=200_000,
             max_output=100_000,
             supports_tools=True,
@@ -79,9 +83,24 @@ class OpenAIAgent(BaseAgent):
             pricing_input=2.0,
             pricing_output=8.0,
         ),
+        ModelInfo(
+            id="gpt-4o",
+            name="GPT-4o",
+            tier="balanced",
+            description="High-speed multimodal flagship for omni-modal coding and vision",
+            context_window=128_000,
+            max_output=16_384,
+            supports_tools=True,
+            supports_streaming=True,
+            supports_vision=True,
+            pricing_input=2.50,
+            pricing_output=10.0,
+        ),
         ModelInfo(
             id="o4-mini",
             name="O4 Mini",
+            tier="balanced",
+            description="Fast and affordable reasoning model for everyday programming",
             context_window=200_000,
             max_output=100_000,
             supports_tools=True,
@@ -91,19 +110,23 @@ class OpenAIAgent(BaseAgent):
             pricing_output=4.40,
         ),
         ModelInfo(
-            id="gpt-4o",
-            name="GPT-4o",
+            id="gpt-4o-mini",
+            name="GPT-4o Mini",
+            tier="fast",
+            description="Lightweight and low-latency model for fast script tasks",
             context_window=128_000,
             max_output=16_384,
             supports_tools=True,
             supports_streaming=True,
             supports_vision=True,
-            pricing_input=2.50,
-            pricing_output=10.0,
+            pricing_input=0.15,
+            pricing_output=0.60,
         ),
         ModelInfo(
             id="codex-mini",
             name="Codex Mini",
+            tier="fast",
+            description="Specialized fast code generation model",
             context_window=200_000,
             max_output=16_384,
             supports_tools=True,
@@ -170,8 +193,47 @@ class OpenAIAgent(BaseAgent):
         ]
         return any(p.exists() for p in app_paths)
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """Check for ChatGPT OAuth via Codex CLI's auth.json."""
+        auth_file = Path.home() / ".codex" / "auth.json"
+        if auth_file.is_file():
+            try:
+                data = json.loads(auth_file.read_text())
+                if data.get("auth_mode") == "chatgpt" and data.get("tokens"):
+                    tokens = data["tokens"]
+                    result: dict[str, str] = {"method": "chatgpt_oauth"}
+                    # Decode plan info from JWT id_token claims (no verification)
+                    id_token = tokens.get("id_token", "")
+                    if id_token:
+                        try:
+                            import base64
+                            parts = id_token.split(".")
+                            if len(parts) >= 2:
+                                payload = parts[1]
+                                padding = 4 - len(payload) % 4
+                                if padding != 4:
+                                    payload += "=" * padding
+                                claims = json.loads(base64.urlsafe_b64decode(payload))
+                                result["account"] = claims.get("email", "")
+                                auth_info = claims.get("https://api.openai.com/auth", {})
+                                result["plan"] = auth_info.get("chatgpt_plan_type", "")
+                        except Exception:
+                            pass
+                    return result
+            except Exception:
+                pass
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        if self._get_api_key():
+            return "api_key"
+        if self._has_cli_auth():
+            return "subscription"
+        return "none"
+
     def is_configured(self) -> bool:
-        return bool(self._get_api_key())
+        return bool(self._get_api_key()) or bool(self._has_cli_auth())
 
     def get_install_info(self) -> dict[str, str]:
         info: dict[str, str] = {"method": "not installed", "path": "", "version": ""}
@@ -210,24 +272,44 @@ class OpenAIAgent(BaseAgent):
 
     def get_subscription_info(self) -> SubscriptionInfo:
         key = self._get_api_key()
-        if not key:
+        if key:
+            if key.startswith("sk-"):
+                return SubscriptionInfo(
+                    tier=SubscriptionTier.PRO,
+                    is_active=True,
+                    message="OpenAI API key detected",
+                )
             return SubscriptionInfo(
                 tier=SubscriptionTier.UNKNOWN,
-                is_active=False,
-                message="No API key found",
+                is_active=True,
+                message="API key detected",
             )
 
-        if key.startswith("sk-"):
+        cli_auth = self._has_cli_auth()
+        if cli_auth:
+            plan = cli_auth.get("plan", "")
+            account = cli_auth.get("account", "")
+            tier_map = {
+                "plus": SubscriptionTier.PRO,
+                "pro": SubscriptionTier.PRO,
+                "team": SubscriptionTier.TEAM,
+                "enterprise": SubscriptionTier.ENTERPRISE,
+            }
+            tier = tier_map.get(plan, SubscriptionTier.UNKNOWN)
+            plan_label = plan.title() if plan else "Active"
+            msg = f"ChatGPT {plan_label}"
+            if account:
+                msg += f" ({account})"
             return SubscriptionInfo(
-                tier=SubscriptionTier.PRO,
+                tier=tier,
                 is_active=True,
-                message="OpenAI API key detected",
+                message=msg,
             )
 
         return SubscriptionInfo(
             tier=SubscriptionTier.UNKNOWN,
-            is_active=True,
-            message="API key detected",
+            is_active=False,
+            message="No credentials found",
         )
 
     # --- Chat ---

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/cli.py

@@ -107,6 +107,8 @@ class ThwipCLI:
         """Main async REPL loop."""
         # 1. Detect agents on system
         detected = self.detector.scan_all()
+        all_agents = self.registry.list_agents()
+        installed_count = len([a for a in all_agents if a.is_installed()])
         ready_count = len(self.registry.get_ready_agents())
 
         # 2. Display startup banner
@@ -118,7 +120,7 @@ class ThwipCLI:
                 model=self.session.current_model,
                 project_path=os.path.abspath(self.session.project_path),
                 session_name=self.session.name,
-                agents_detected=len(detected),
+                agents_detected=installed_count,
                 agents_ready=ready_count,
             )
         )
@@ -195,8 +197,11 @@ class ThwipCLI:
         elif cmd in ("/agents", "/list"):
             self.cmd_show_agents()
 
+        elif cmd in ("/key", "/auth", "/config"):
+            self.cmd_auth_config(arg1, arg2)
+
         elif cmd in ("/models", "/m"):
-            self.cmd_show_models(arg1)
+            self.cmd_show_models(arg1, arg2)
 
         elif cmd == "/tools":
             self.cmd_show_tools()
@@ -298,7 +303,8 @@ class ThwipCLI:
             ("/about", "Display full About section, architecture, and navigation guide"),
             ("/switch [agent] [model]", "Switch active agent/model mid-conversation without losing context"),
             ("/agents", "Show all detected coding agents, company status & capabilities"),
-            ("/models [agent]", "List available models for current or target agent"),
+            ("/models [agent|tier]", "List models filtered by provider or tier (flagship, balanced, fast)"),
+            ("/key [provider] [key]", "View or configure API keys saved in ~/.thwip/config.toml"),
             ("/tools", "List all universal file, terminal, and git tools"),
             ("/status", "Display current session, project, and token stats"),
             ("/limits", "View token usage, quota, and spend metrics"),
@@ -322,15 +328,19 @@ class ThwipCLI:
     async def cmd_switch(self, agent_name: str, model_id: str = "") -> None:
         """Switch to a different agent and/or model."""
         if not agent_name:
-            agents = self.registry.list_agents()
-            console.print("\n[bold white]Available Coding Agents on Your Machine:[/bold white]")
+            all_agents = self.registry.list_agents()
+            installed = [a for a in all_agents if a.is_installed()]
 
-            # Group: Ready / Configured
-            ready_agents = [a for a in agents if a.is_configured()]
-            installed_agents = [a for a in agents if a.is_installed() and not a.is_configured()]
-            other_agents = [a for a in agents if not a.is_installed()]
+            if not installed:
+                print_error("No agents detected on your machine.")
+                return
+
+            console.print("\n[bold white]Available Coding Agents on Your Machine:[/bold white]")
 
-            ordered = ready_agents + installed_agents + other_agents
+            # Sort: configured first, then just installed
+            ready_agents = [a for a in installed if a.is_configured()]
+            unready_agents = [a for a in installed if not a.is_configured()]
+            ordered = ready_agents + unready_agents
 
             for i, a in enumerate(ordered, 1):
                 brand = get_brand(a.company)
@@ -343,10 +353,14 @@ class ThwipCLI:
                     f"({a.company}) - [{status_style}][{status_str}][/{status_style}][dim]{loc}[/dim]"
                 )
 
+            not_installed = len(all_agents) - len(installed)
+            if not_installed > 0:
+                console.print(f"\n  [dim]{not_installed} other providers available (DeepSeek, Groq, Ollama, OpenRouter). Use /agents to see all.[/dim]")
+
             choice = input(f"\nEnter choice [1-{len(ordered)}]: ").strip()
             if choice.isdigit() and 1 <= int(choice) <= len(ordered):
                 agent_name = ordered[int(choice) - 1].name
-            elif choice.lower() in [a.name for a in agents]:
+            elif choice.lower() in [a.name for a in installed]:
                 agent_name = choice.lower()
             else:
                 print_warning("Switch cancelled.")
@@ -397,33 +411,142 @@ class ThwipCLI:
         rows = [a.to_table_row() for a in self.registry.list_agents()]
         console.print(render_agents_table(rows))
 
-    def cmd_show_models(self, agent_name: str = "") -> None:
-        """List models for current or target agent."""
-        target = self.registry.get_agent(agent_name) if agent_name else self.current_agent
-        if not target:
-            print_error(f"Agent '{agent_name}' not found.")
-            return
+    def cmd_show_models(self, arg1: str = "", arg2: str = "") -> None:
+        """List models by provider or tier (flagship, balanced, fast)."""
+        tier_filter = ""
+        agent_target = None
+
+        tier_aliases = {
+            "flagship": "flagship",
+            "high": "flagship",
+            "pro": "flagship",
+            "balanced": "balanced",
+            "mid": "balanced",
+            "flash": "balanced",
+            "fast": "fast",
+            "low": "fast",
+            "lite": "fast",
+            "mini": "fast",
+        }
+
+        if arg1.lower() in tier_aliases:
+            tier_filter = tier_aliases[arg1.lower()]
+        elif arg1:
+            agent_target = self.registry.get_agent(arg1)
+            if not agent_target:
+                print_error(f"Agent '{arg1}' not found.")
+                return
+            if arg2.lower() in tier_aliases:
+                tier_filter = tier_aliases[arg2.lower()]
 
-        table = Table(title=f"Available Models for {target.display_name}", box=box.ROUNDED)
+        if not agent_target and not tier_filter:
+            agent_target = self.current_agent
+
+        if agent_target:
+            agents_to_show = [agent_target]
+            title = f"Available Models for {agent_target.display_name}"
+            if tier_filter:
+                title += f" ({tier_filter.title()} Tier)"
+        else:
+            agents_to_show = self.registry.list_agents()
+            title = f"All {tier_filter.title()} Tier Models Across Providers"
+
+        table = Table(title=title, box=box.ROUNDED)
+        if not agent_target:
+            table.add_column("Provider", style="cyan")
         table.add_column("Model ID", style="bold white")
-        table.add_column("Name", style="cyan")
-        table.add_column("Context", style="white")
-        table.add_column("Tools", style="green")
+        table.add_column("Name", style="white")
+        table.add_column("Tier", style="bold")
+        table.add_column("Context", style="dim")
         table.add_column("Thinking", style="magenta")
-        table.add_column("Price (In/Out per 1M)", style="dim")
+        table.add_column("Price (In/Out 1M)", style="green")
+
+        tier_styles = {
+            "flagship": "[bold magenta]Flagship / High[/bold magenta]",
+            "balanced": "[bold cyan]Balanced / Mid[/bold cyan]",
+            "fast": "[bold green]Fast / Low[/bold green]",
+        }
+
+        for ag in agents_to_show:
+            for m in ag.available_models:
+                m_tier = getattr(m, "tier", "balanced")
+                if tier_filter and m_tier != tier_filter:
+                    continue
+
+                ctx = f"{m.context_window:,}" if m.context_window else "-"
+                price = f"${m.pricing_input} / ${m.pricing_output}" if m.pricing_input else "Free"
+                tier_badge = tier_styles.get(m_tier, m_tier.title())
+                def_mark = " [dim](default)[/dim]" if m.is_default else ""
+
+                row = []
+                if not agent_target:
+                    row.append(ag.company)
+                row.extend([
+                    m.id + def_mark,
+                    m.name,
+                    tier_badge,
+                    ctx,
+                    "yes" if m.supports_thinking else "-",
+                    price,
+                ])
+                table.add_row(*row)
+
+        console.print(table)
+        console.print("[dim]Filter by tier: [bold]/models flagship[/bold], [bold]/models balanced[/bold], [bold]/models fast[/bold][/dim]\n")
+
+    def cmd_auth_config(self, provider: str = "", key: str = "") -> None:
+        """View or set API credentials stored in ~/.thwip/config.toml."""
+        provider_map = {
+            "google": "google",
+            "gemini": "google",
+            "antigravity": "google",
+            "openai": "openai",
+            "chatgpt": "openai",
+            "codex": "openai",
+            "claude": "anthropic",
+            "anthropic": "anthropic",
+            "deepseek": "deepseek",
+            "groq": "groq",
+            "openrouter": "openrouter",
+        }
+
+        if provider and key:
+            target_prov = provider_map.get(provider.lower(), provider.lower())
+            self.config.keys[target_prov] = key
+            self.config.key_sources[target_prov] = "config.toml"
+            self.config.save()
+
+            # Refresh agent registry
+            self.registry = AgentRegistry(self.config)
+            agent = self.registry.get_agent(self.session.current_agent)
+            if agent:
+                self.current_agent = agent
+            print_success(f"API key for '{target_prov}' saved to ~/.thwip/config.toml")
+            return
+
+        # Show interactive auth overview
+        table = Table(title="thwip API Credentials & Authentication", box=box.ROUNDED)
+        table.add_column("Provider", style="bold white")
+        table.add_column("Auth Status", style="white")
+        table.add_column("Key Source", style="dim")
+        table.add_column("Config Command", style="cyan")
+
+        for prov, label in [
+            ("google", "Google Gemini / Antigravity"),
+            ("openai", "OpenAI / ChatGPT / Codex"),
+            ("anthropic", "Anthropic Claude"),
+            ("deepseek", "DeepSeek"),
+            ("groq", "Groq"),
+            ("openrouter", "OpenRouter"),
+        ]:
+            has_key = bool(self.config.keys.get(prov))
+            source = self.config.key_sources.get(prov, "none")
+            status = "[bold green]Configured[/bold green]" if has_key else "[bold yellow]Missing[/bold yellow]"
+            cmd_hint = f"/key {prov} <your_api_key>"
+            table.add_row(label, status, source, cmd_hint)
 
-        for m in target.available_models:
-            ctx = f"{m.context_window:,}" if m.context_window else "-"
-            price = f"${m.pricing_input} / ${m.pricing_output}" if m.pricing_input else "Free / Local"
-            table.add_row(
-                m.id + (" (default)" if m.is_default else ""),
-                m.name,
-                ctx,
-                "yes" if m.supports_tools else "-",
-                "yes" if m.supports_thinking else "-",
-                price,
-            )
         console.print(table)
+        console.print("[dim]To set a key: [bold white]/key <provider> <key>[/bold white] (e.g. /key google AIzaSy...)[/dim]\n")
 
     def cmd_show_status(self) -> None:
         """Display status."""

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/thwip/theme.py

@@ -16,6 +16,8 @@ from rich.table import Table
 from rich.text import Text
 from rich.theme import Theme
 from rich.markdown import Markdown
+
+from thwip import __version__
 from rich.syntax import Syntax
 from rich import box
 
@@ -151,7 +153,7 @@ def render_startup_banner(
     lines.append("╚═╝   ╚═╝  ╚═╝ ╚══╝╚══╝ ╚═╝╚═╝     \n\n", style="dim")
 
     lines.append("  Universal Coding Agent Multiplexer", style="bold white")
-    lines.append("  v1.0.2\n\n", style="dim")
+    lines.append(f"  v{__version__}\n\n", style="dim")
     lines.append("  Agent:       ", style="dim")
     lines.append(f"{agent_name}", style=brand.label_style)
     lines.append(f" ({company})\n", style="dim")
@@ -163,7 +165,7 @@ def render_startup_banner(
     lines.append(f"{session_name}\n", style="white")
     lines.append("  Environment: ", style="dim")
     lines.append(f"{agents_detected}", style="bold white")
-    lines.append(" tools detected, ", style="dim")
+    lines.append(" agents installed, ", style="dim")
     lines.append(f"{agents_ready}", style="success")
     lines.append(" ready\n\n", style="dim")
     lines.append("  Quickstart:  Type ", style="dim")

{thwip_cli-1.0.2 → thwip_cli-1.0.4}/uv.lock

@@ -1022,7 +1022,7 @@ wheels = [
 
 [[package]]
 name = "thwip-cli"
-version = "1.0.2"
+version = "1.0.4"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },