sandboxy 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

sandboxy/cli/main.py

@@ -98,6 +98,137 @@ def _load_variables_from_env() -> dict:
         return {}
 
 
+def _export_to_mlflow(
+    result: Any,
+    spec: Any,
+    scenario_path: Path,
+    mlflow_export: bool,
+    no_mlflow: bool,
+    mlflow_tracking_uri: str | None,
+    mlflow_experiment: str | None,
+    agent_name: str = "default",
+) -> None:
+    """Export scenario result to MLflow if enabled.
+
+    Args:
+        result: ScenarioResult from runner
+        spec: ScenarioSpec
+        scenario_path: Path to scenario file
+        mlflow_export: --mlflow-export flag
+        no_mlflow: --no-mlflow flag
+        mlflow_tracking_uri: --mlflow-tracking-uri value
+        mlflow_experiment: --mlflow-experiment value
+        agent_name: Agent configuration name
+    """
+    from sandboxy.mlflow.config import MLflowConfig
+
+    # Get YAML config from spec
+    yaml_config = None
+    if spec.mlflow:
+        yaml_config = {
+            "enabled": spec.mlflow.enabled,
+            "experiment": spec.mlflow.experiment,
+            "tracking_uri": spec.mlflow.tracking_uri,
+            "tags": spec.mlflow.tags,
+        }
+
+    # Resolve config with precedence
+    config = MLflowConfig.resolve(
+        cli_export=mlflow_export,
+        cli_no_mlflow=no_mlflow,
+        cli_tracking_uri=mlflow_tracking_uri,
+        cli_experiment=mlflow_experiment,
+        yaml_config=yaml_config,
+        scenario_name=spec.name,
+    )
+
+    if not config.enabled:
+        return
+
+    # Import and use exporter
+    try:
+        from sandboxy.mlflow.exporter import MLflowExporter
+
+        exporter = MLflowExporter(config)
+
+        # Convert ScenarioResult to RunResult-like for exporter
+        # ScenarioResult has different structure, create adapter
+        run_id = exporter.export(
+            result=_adapt_scenario_result(result),
+            scenario_path=scenario_path,
+            scenario_name=spec.name,
+            scenario_id=spec.id,
+            agent_name=agent_name,
+        )
+
+        if run_id:
+            click.echo(f"\nExported to MLflow: run_id={run_id}")
+
+    except ImportError:
+        click.echo(
+            "\nMLflow not installed. Install with: pip install sandboxy[mlflow]",
+            err=True,
+        )
+    except Exception as e:
+        click.echo(f"\nWarning: MLflow export failed: {e}", err=True)
+
+
+def _adapt_scenario_result(result: Any) -> Any:
+    """Adapt ScenarioResult to RunResult-like interface for MLflowExporter.
+
+    The exporter expects RunResult fields, but ScenarioRunner returns ScenarioResult.
+    This creates an adapter object.
+    """
+    from dataclasses import dataclass, field
+
+    @dataclass
+    class GoalResultAdapter:
+        name: str
+        score: float
+        passed: bool = True
+
+    @dataclass
+    class EvaluationAdapter:
+        goals: list[GoalResultAdapter] = field(default_factory=list)
+        total_score: float = 0.0
+        max_score: float = 0.0
+        percentage: float = 0.0
+
+    @dataclass
+    class RunResultAdapter:
+        model: str = ""
+        error: str | None = None
+        latency_ms: int = 0
+        input_tokens: int = 0
+        output_tokens: int = 0
+        evaluation: EvaluationAdapter | None = None
+
+    # Extract data from ScenarioResult
+    adapter = RunResultAdapter(
+        model=getattr(result, "agent_id", "unknown"),
+        error=None,
+    )
+
+    # Build evaluation from goals
+    goals = []
+    total = 0.0
+    for goal_name in getattr(result, "goals_achieved", []):
+        goals.append(GoalResultAdapter(name=goal_name, score=1.0, passed=True))
+        total += 1.0
+
+    score = getattr(result, "score", 0.0)
+    max_score = max(score, len(goals)) if goals else score
+
+    adapter.evaluation = EvaluationAdapter(
+        goals=goals,
+        total_score=score,
+        max_score=max_score,
+        percentage=(score / max_score * 100) if max_score > 0 else 0.0,
+    )
+
+    return adapter
+
+
 @main.command()
 @click.option("--with-examples", is_flag=True, help="Include example scenarios and tools")
 @click.option(
@@ -528,22 +659,54 @@ def info(module_path: str) -> None:
 @click.option(
     "--model",
     "-m",
-    help="Model to use (e.g., openai/gpt-4o, anthropic/claude-3.5-sonnet)",
-    default=None,
+    multiple=True,
+    help="Model(s) to use. Can specify multiple: -m gpt-4o -m claude-3.5-sonnet",
 )
 @click.option("--agent-id", "-a", help="Agent ID from config files", default=None)
 @click.option("--output", "-o", help="Output file for results JSON", default=None)
 @click.option("--pretty", "-p", is_flag=True, help="Pretty print output")
 @click.option("--max-turns", type=int, default=20, help="Maximum conversation turns")
 @click.option("--var", "-v", multiple=True, help="Variable in name=value format")
+@click.option(
+    "--mlflow-export",
+    is_flag=True,
+    help="Export run results to MLflow tracking server",
+)
+@click.option(
+    "--no-mlflow",
+    is_flag=True,
+    help="Disable MLflow export (overrides YAML config)",
+)
+@click.option(
+    "--mlflow-tracking-uri",
+    type=str,
+    default=None,
+    help="MLflow tracking server URI (overrides MLFLOW_TRACKING_URI env)",
+)
+@click.option(
+    "--mlflow-experiment",
+    type=str,
+    default=None,
+    help="MLflow experiment name (defaults to scenario name)",
+)
+@click.option(
+    "--mlflow-no-tracing",
+    is_flag=True,
+    help="Disable LLM call tracing (only log summary metrics)",
+)
 def scenario(
     scenario_path: str,
-    model: str | None,
+    model: tuple[str, ...],
     agent_id: str | None,
     output: str | None,
     pretty: bool,
     max_turns: int,
     var: tuple[str, ...],
+    mlflow_export: bool,
+    no_mlflow: bool,
+    mlflow_tracking_uri: str | None,
+    mlflow_experiment: str | None,
+    mlflow_no_tracing: bool,
 ) -> None:
     """Run a scenario with YAML-defined tools.
 
@@ -554,8 +717,10 @@ def scenario(
 
     Examples:
         sandboxy scenario scenarios/trolley.yml -m openai/gpt-4o
-        sandboxy scenario scenarios/trolley.yml -m anthropic/claude-3.5-sonnet -p
+        sandboxy scenario scenarios/trolley.yml -m gpt-4o -m claude-3.5-sonnet  # multiple models
         sandboxy scenario scenarios/surgeon.yml -v patient="John Smith" -v condition="critical"
+        sandboxy scenario scenarios/test.yml -m gpt-4o --mlflow-export
+        sandboxy scenario scenarios/test.yml -m gpt-4o -m gpt-4o-mini --mlflow-export  # compare models
     """
     from sandboxy.agents.base import AgentConfig
     from sandboxy.agents.llm_prompt import LlmPromptAgent
@@ -567,6 +732,26 @@ def scenario(
         click.echo(f"Error loading scenario: {e}", err=True)
         sys.exit(1)
 
+    # Build MLflow config if export requested
+    mlflow_config = None
+    if mlflow_export and not no_mlflow:
+        try:
+            from sandboxy.mlflow import MLflowConfig
+
+            mlflow_config = MLflowConfig.resolve(
+                cli_export=True,
+                cli_tracking_uri=mlflow_tracking_uri,
+                cli_experiment=mlflow_experiment,
+                cli_tracing=not mlflow_no_tracing,
+                yaml_config=spec.mlflow.model_dump() if spec.mlflow else None,
+                scenario_name=spec.name,
+            )
+            click.echo(f"MLflow enabled → experiment: {mlflow_config.experiment}")
+            if mlflow_config.tracing:
+                click.echo("  Tracing: ON (LLM calls will be captured)")
+        except ImportError:
+            pass  # MLflow not installed
+
     # Parse and apply variables
     variables: dict[str, Any] = {}
     for v in var:
@@ -582,27 +767,17 @@ def scenario(
         spec = apply_scenario_variables(spec, variables)
         click.echo(f"Variables: {variables}")
 
-    # Determine which agent to use
-    agent = None
+    # Build list of models to run
+    models_to_run: list[str] = []
 
     if model:
-        # Create ad-hoc agent from model string
-        config = AgentConfig(
-            id=model,
-            name=model.split("/")[-1] if "/" in model else model,
-            kind="llm-prompt",
-            model=model,
-            system_prompt="",
-            tools=[],
-            params={"temperature": 0.7, "max_tokens": 4096},
-            impl={},
-        )
-        agent = LlmPromptAgent(config)
+        models_to_run = list(model)
     elif agent_id:
         # Load from agent config files
         loader = AgentLoader(DEFAULT_AGENT_DIRS)
         try:
             agent = loader.load(agent_id)
+            models_to_run = [agent.config.model]
         except ValueError as e:
             click.echo(f"Error loading agent: {e}", err=True)
             sys.exit(1)
@@ -611,6 +786,7 @@ def scenario(
         loader = AgentLoader(DEFAULT_AGENT_DIRS)
         try:
             agent = loader.load_default()
+            models_to_run = [agent.config.model]
         except ValueError:
             click.echo("No model specified. Use -m to specify a model:", err=True)
             click.echo("", err=True)
@@ -623,25 +799,110 @@ def scenario(
             )
             sys.exit(1)
 
-    # Apply scenario's system prompt to agent
-    if spec.system_prompt:
-        agent.config.system_prompt = spec.system_prompt
-
     click.echo(f"Running scenario: {spec.name}")
-    click.echo(f"Using model: {agent.config.model}")
+    click.echo(f"Models: {', '.join(models_to_run)}")
     click.echo(f"Tools loaded: {len(spec.tools) + len(spec.tools_from)} source(s)")
+    if len(models_to_run) > 1:
+        click.echo("Running models in parallel...")
     click.echo("")
 
-    runner = ScenarioRunner(scenario=spec, agent=agent)
-    result = runner.run(max_turns=max_turns)
+    def run_single_model(model_id: str) -> dict[str, Any]:
+        """Run scenario with a single model, with MLflow tracing if enabled."""
+        agent_config = AgentConfig(
+            id=model_id,
+            name=model_id.split("/")[-1] if "/" in model_id else model_id,
+            kind="llm-prompt",
+            model=model_id,
+            system_prompt=spec.system_prompt or "",
+            tools=[],
+            params={"temperature": 0.7, "max_tokens": 4096},
+            impl={},
+        )
+        agent = LlmPromptAgent(agent_config)
+
+        # If MLflow enabled, wrap execution in run context so traces are connected
+        if mlflow_config and mlflow_config.enabled:
+            from sandboxy.mlflow import MLflowExporter, mlflow_run_context
+            from sandboxy.mlflow.tracing import enable_tracing
+
+            # Enable tracing before the run starts
+            if mlflow_config.tracing:
+                enable_tracing(
+                    tracking_uri=mlflow_config.tracking_uri,
+                    experiment_name=mlflow_config.experiment,
+                )
+
+            # Start run, execute scenario, then log metrics - all connected
+            with mlflow_run_context(mlflow_config, run_name=model_id) as run_id:
+                runner = ScenarioRunner(scenario=spec, agent=agent)
+                result = runner.run(max_turns=max_turns)
+
+                # Log metrics to the active run (traces are already attached)
+                if run_id:
+                    exporter = MLflowExporter(mlflow_config)
+                    exporter.log_to_active_run(
+                        result=result,
+                        scenario_path=Path(scenario_path),
+                        scenario_name=spec.name,
+                        scenario_id=spec.id,
+                        agent_name=agent.config.name,
+                    )
+
+            return {"model": model_id, "result": result, "agent_name": agent.config.name}
+
+        # No MLflow - just run scenario
+        runner = ScenarioRunner(scenario=spec, agent=agent)
+        result = runner.run(max_turns=max_turns)
+        return {"model": model_id, "result": result, "agent_name": agent.config.name}
+
+    # Run models in parallel if multiple, otherwise just run single
+    results: list[Any] = []
+    if len(models_to_run) == 1:
+        results = [run_single_model(models_to_run[0])]
+    else:
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        with ThreadPoolExecutor(max_workers=len(models_to_run)) as executor:
+            futures = {executor.submit(run_single_model, m): m for m in models_to_run}
+            for future in as_completed(futures):
+                model_id = futures[future]
+                try:
+                    result_data = future.result()
+                    results.append(result_data)
+                    click.echo(f"✓ Completed: {model_id}")
+                except Exception as e:
+                    click.echo(f"✗ Failed: {model_id} - {e}", err=True)
+        click.echo("")
 
-    if output:
-        Path(output).write_text(result.to_json(indent=2))
-        click.echo(f"\nResults saved to: {output}")
-    elif pretty:
-        click.echo(result.pretty())
+    # Output results
+    if len(results) == 1:
+        result = results[0]["result"]
+        if output:
+            Path(output).write_text(result.to_json(indent=2))
+            click.echo(f"\nResults saved to: {output}")
+        elif pretty:
+            click.echo(result.pretty())
+        else:
+            click.echo(result.to_json(indent=2))
     else:
-        click.echo(result.to_json(indent=2))
+        # Multiple models - show summary
+        # Get max_score from spec (scoring config or sum of goal points)
+        max_score = spec.scoring.get("max_score", 0) if spec.scoring else 0
+        if not max_score and spec.goals:
+            max_score = sum(g.points for g in spec.goals)
+
+        click.echo("=== Results Summary ===")
+        for r in results:
+            model_name = r["model"]
+            res = r["result"]
+            score = getattr(res, "score", 0) or 0
+            pct = (score / max_score * 100) if max_score > 0 else 0
+            click.echo(f"  {model_name}: {score:.1f}/{max_score:.1f} ({pct:.0f}%)")
+
+        if output:
+            all_results = [{"model": r["model"], "result": r["result"].to_dict()} for r in results]
+            Path(output).write_text(json.dumps(all_results, indent=2))
+            click.echo(f"\nResults saved to: {output}")
 
 
 @main.command()
@@ -1333,5 +1594,376 @@ def mcp_list_servers() -> None:
     click.echo("More servers: https://github.com/modelcontextprotocol/servers")
 
 
+# =============================================================================
+# PROVIDERS COMMAND GROUP
+# =============================================================================
+
+
+@main.group()
+def providers() -> None:
+    """Manage local model providers (Ollama, LM Studio, vLLM, etc.)."""
+    pass
+
+
+@providers.command("list")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def providers_list(as_json: bool) -> None:
+    """List all configured local providers.
+
+    Shows provider name, type, URL, connection status, and model count.
+
+    Examples:
+        sandboxy providers list
+        sandboxy providers list --json
+    """
+    import asyncio
+
+    from sandboxy.providers.config import load_providers_config
+    from sandboxy.providers.local import LocalProvider
+
+    config = load_providers_config()
+
+    if not config.providers:
+        if as_json:
+            click.echo(json.dumps({"providers": []}))
+        else:
+            click.echo("No local providers configured.")
+            click.echo("")
+            click.echo("Add a provider with:")
+            click.echo("  sandboxy providers add ollama --url http://localhost:11434/v1")
+        return
+
+    async def get_statuses():
+        results = []
+        for pconfig in config.providers:
+            provider = LocalProvider(pconfig)
+            try:
+                status = await provider.test_connection()
+                results.append(
+                    {
+                        "name": pconfig.name,
+                        "type": pconfig.type,
+                        "base_url": pconfig.base_url,
+                        "enabled": pconfig.enabled,
+                        "status": status.status.value,
+                        "model_count": len(status.available_models),
+                    }
+                )
+            except Exception as e:
+                results.append(
+                    {
+                        "name": pconfig.name,
+                        "type": pconfig.type,
+                        "base_url": pconfig.base_url,
+                        "enabled": pconfig.enabled,
+                        "status": "error",
+                        "model_count": 0,
+                        "error": str(e),
+                    }
+                )
+            finally:
+                await provider.close()
+        return results
+
+    statuses = asyncio.run(get_statuses())
+
+    if as_json:
+        click.echo(json.dumps({"providers": statuses}, indent=2))
+        return
+
+    # Table output
+    click.echo(f"{'NAME':<15} {'TYPE':<18} {'URL':<35} {'STATUS':<12} {'MODELS':<6}")
+    for s in statuses:
+        status_display = s["status"]
+        if s["status"] == "connected":
+            status_display = click.style("connected", fg="green")
+        elif s["status"] in ("disconnected", "error"):
+            status_display = click.style(s["status"], fg="red")
+
+        click.echo(
+            f"{s['name']:<15} {s['type']:<18} {s['base_url']:<35} {status_display:<12} {s['model_count']:<6}"
+        )
+
+
+@providers.command("add")
+@click.argument("name")
+@click.option(
+    "--type",
+    "provider_type",
+    type=click.Choice(["ollama", "lmstudio", "vllm", "openai-compatible"]),
+    default="openai-compatible",
+    help="Provider type",
+)
+@click.option("--url", required=True, help="Base URL for the provider API")
+@click.option("--api-key", help="Optional API key for authentication")
+@click.option("--model", "models", multiple=True, help="Manually specify model (can be repeated)")
+@click.option("--no-test", is_flag=True, help="Skip connection test")
+def providers_add(
+    name: str,
+    provider_type: str,
+    url: str,
+    api_key: str | None,
+    models: tuple[str, ...],
+    no_test: bool,
+) -> None:
+    """Add a new local model provider.
+
+    Examples:
+        sandboxy providers add ollama --url http://localhost:11434/v1
+        sandboxy providers add my-vllm --type vllm --url http://gpu:8000/v1 --api-key $KEY
+        sandboxy providers add custom --url http://localhost:8080/v1 --model llama3 --model mistral
+    """
+    import asyncio
+
+    from sandboxy.providers.config import (
+        LocalProviderConfig,
+        load_providers_config,
+        save_providers_config,
+    )
+    from sandboxy.providers.local import LocalProvider
+    from sandboxy.providers.registry import reload_local_providers
+
+    # Load existing config
+    config = load_providers_config()
+
+    # Check for duplicate name
+    if config.get_provider(name):
+        click.echo(f"Error: Provider '{name}' already exists", err=True)
+        sys.exit(1)
+
+    # Create provider config
+    try:
+        provider_config = LocalProviderConfig(
+            name=name,
+            type=provider_type,
+            base_url=url,
+            api_key=api_key,
+            models=list(models),
+        )
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+    # Test connection unless skipped
+    discovered_models: list[str] = []
+    if not no_test:
+        click.echo(f"Testing connection to {url}...")
+
+        async def test():
+            provider = LocalProvider(provider_config)
+            try:
+                status = await provider.test_connection()
+                return status
+            finally:
+                await provider.close()
+
+        try:
+            status = asyncio.run(test())
+            if status.status.value == "connected":
+                click.echo(click.style("✓ Connected", fg="green"))
+                discovered_models = status.available_models
+                if discovered_models:
+                    click.echo(f"✓ Found {len(discovered_models)} models")
+            else:
+                click.echo(click.style(f"✗ Connection failed: {status.error_message}", fg="red"))
+                click.echo("")
+                click.echo("Provider will be added but may not work until server is running.")
+                click.echo("Use --no-test to skip this check.")
+                sys.exit(2)
+        except Exception as e:
+            click.echo(click.style(f"✗ Connection failed: {e}", fg="red"))
+            sys.exit(2)
+
+    # Add and save
+    config.add_provider(provider_config)
+    save_providers_config(config)
+
+    # Reload providers in registry
+    reload_local_providers()
+
+    click.echo(f"Added provider '{name}'")
+    if discovered_models:
+        model_list = ", ".join(discovered_models[:5])
+        if len(discovered_models) > 5:
+            model_list += f", ... ({len(discovered_models) - 5} more)"
+        click.echo(f"Found {len(discovered_models)} models: {model_list}")
+    elif models:
+        click.echo(f"Configured {len(models)} model(s): {', '.join(models)}")
+
+
+@providers.command("remove")
+@click.argument("name")
+def providers_remove(name: str) -> None:
+    """Remove a configured provider.
+
+    Examples:
+        sandboxy providers remove ollama
+    """
+    from sandboxy.providers.config import load_providers_config, save_providers_config
+    from sandboxy.providers.registry import reload_local_providers
+
+    config = load_providers_config()
+
+    if not config.remove_provider(name):
+        click.echo(f"Error: Provider '{name}' not found", err=True)
+        sys.exit(1)
+
+    save_providers_config(config)
+    reload_local_providers()
+
+    click.echo(f"Removed provider '{name}'")
+
+
+@providers.command("test")
+@click.argument("name")
+def providers_test(name: str) -> None:
+    """Test connection to a provider.
+
+    Examples:
+        sandboxy providers test ollama
+    """
+    import asyncio
+
+    from sandboxy.providers.config import load_providers_config
+    from sandboxy.providers.local import LocalProvider
+
+    config = load_providers_config()
+    provider_config = config.get_provider(name)
+
+    if not provider_config:
+        click.echo(f"Error: Provider '{name}' not found", err=True)
+        sys.exit(1)
+
+    click.echo(f"Testing connection to {name} ({provider_config.base_url})...")
+
+    async def test():
+        provider = LocalProvider(provider_config)
+        try:
+            return await provider.test_connection()
+        finally:
+            await provider.close()
+
+    try:
+        status = asyncio.run(test())
+
+        if status.status.value == "connected":
+            click.echo(click.style(f"✓ Connected in {status.latency_ms}ms", fg="green"))
+            if status.available_models:
+                click.echo(
+                    f"✓ Found {len(status.available_models)} models: {', '.join(status.available_models)}"
+                )
+        else:
+            click.echo(click.style(f"✗ Connection failed: {status.error_message}", fg="red"))
+
+            # Provide helpful suggestions based on provider type
+            if provider_config.type == "ollama":
+                click.echo("")
+                click.echo("  Suggestion: Ensure Ollama is running with: ollama serve")
+            elif provider_config.type == "vllm":
+                click.echo("")
+                click.echo(
+                    "  Suggestion: Start vLLM with: python -m vllm.entrypoints.openai.api_server"
+                )
+            elif provider_config.type == "lmstudio":
+                click.echo("")
+                click.echo("  Suggestion: Start the server in LM Studio and load a model")
+
+            sys.exit(1)
+
+    except Exception as e:
+        click.echo(click.style(f"✗ Error: {e}", fg="red"))
+        sys.exit(1)
+
+
+@providers.command("models")
+@click.argument("name", required=False)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def providers_models(name: str | None, as_json: bool) -> None:
+    """List models from configured providers.
+
+    If NAME is provided, shows models only from that provider.
+    Otherwise, shows models from all providers.
+
+    Examples:
+        sandboxy providers models
+        sandboxy providers models ollama
+        sandboxy providers models --json
+    """
+    import asyncio
+
+    from sandboxy.providers.config import load_providers_config
+    from sandboxy.providers.local import LocalProvider
+
+    config = load_providers_config()
+
+    if name:
+        provider_config = config.get_provider(name)
+        if not provider_config:
+            click.echo(f"Error: Provider '{name}' not found", err=True)
+            sys.exit(1)
+        providers_to_check = [provider_config]
+    else:
+        providers_to_check = [p for p in config.providers if p.enabled]
+
+    if not providers_to_check:
+        if as_json:
+            click.echo(json.dumps({"models": []}))
+        else:
+            click.echo("No providers configured.")
+        return
+
+    async def get_models():
+        all_models = []
+        for pconfig in providers_to_check:
+            provider = LocalProvider(pconfig)
+            try:
+                models = await provider.refresh_models()
+                for m in models:
+                    all_models.append(
+                        {
+                            "provider": pconfig.name,
+                            "id": m.id,
+                            "name": m.name,
+                            "context_length": m.context_length,
+                            "supports_tools": m.supports_tools,
+                        }
+                    )
+            except Exception:
+                # Provider unreachable, use configured models if any
+                for model_id in pconfig.models:
+                    all_models.append(
+                        {
+                            "provider": pconfig.name,
+                            "id": model_id,
+                            "name": model_id,
+                            "context_length": 0,
+                            "supports_tools": False,
+                        }
+                    )
+            finally:
+                await provider.close()
+        return all_models
+
+    models = asyncio.run(get_models())
+
+    if as_json:
+        output = {"models": models}
+        if name:
+            output["provider"] = name
+        click.echo(json.dumps(output, indent=2))
+        return
+
+    if not models:
+        click.echo("No models found. Is the provider running?")
+        return
+
+    # Table output
+    click.echo(f"{'PROVIDER':<15} {'MODEL':<40} {'TOOLS':<6} {'CONTEXT':<10}")
+    for m in models:
+        tools = "✓" if m["supports_tools"] else "✗"
+        ctx = str(m["context_length"]) if m["context_length"] > 0 else "?"
+        click.echo(f"{m['provider']:<15} {m['id']:<40} {tools:<6} {ctx:<10}")
+
+
 if __name__ == "__main__":
     main()