feat: add models-list command

wip

wip

Author: GabrielVasilescu04

packages/uipath/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.10.53"
+version = "2.10.54"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

packages/uipath/src/uipath/_cli/__init__.py

@@ -45,6 +45,7 @@
     "server": "cli_server",
     "register": "cli_register",
     "debug": "cli_debug",
+    "list": "cli_list",
     "assets": "services.cli_assets",
     "buckets": "services.cli_buckets",
     "context-grounding": "services.cli_context_grounding",

packages/uipath/src/uipath/_cli/_utils/_resources.py

@@ -1,5 +1,7 @@
 import enum
 
+import click
+
 from ._console import ConsoleLogger
 
 console = ConsoleLogger().get_instance()
@@ -20,3 +22,19 @@ def from_string(cls, resource: str) -> "Resources":
                 f"Invalid resource type: '{resource}'. Valid types are: {valid_resources}"
             )
             raise
+
+
+class Listable(str, enum.Enum):
+    """Available resources that can be listed via `uipath list <resource>`."""
+
+    MODELS = "models"
+
+    @classmethod
+    def from_string(cls, resource: str) -> "Listable":
+        try:
+            return Listable(resource)
+        except ValueError as e:
+            valid = ", ".join(r.value for r in Listable)
+            raise click.ClickException(
+                f"Invalid resource type: '{resource}'. Valid types are: {valid}"
+            ) from e

packages/uipath/src/uipath/_cli/cli_list.py

@@ -0,0 +1,26 @@
+import click
+
+from ._utils._resources import Listable
+from ._utils._service_base import ServiceCommandBase, service_command
+
+
+@click.command(name="list")
+@click.argument("resource", required=True)
+@click.option(
+    "--format",
+    type=click.Choice(["json", "table", "csv"]),
+    help="Output format (overrides global)",
+)
+@click.option("--output", "-o", type=click.Path(), help="Output file")
+@service_command
+async def list(ctx, resource, format, output):
+    """List available UiPath resources.
+
+    \b
+    Examples:
+        uipath list models
+    """  # noqa: D301
+    match Listable.from_string(resource):
+        case Listable.MODELS:
+            client = ServiceCommandBase.get_client(ctx)
+            return await client.agenthub.get_available_llm_models_async()

packages/uipath/tests/cli/integration/test_list_commands.py

@@ -0,0 +1,202 @@
+"""Integration tests for the generic `uipath list <resource>` CLI command.
+
+These tests verify dispatch to each supported resource handler, output
+formatting, and error handling.
+"""
+
+import json
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from click.testing import CliRunner
+
+from uipath._cli import cli
+from uipath.platform.agenthub import LlmModel
+
+
+@pytest.fixture
+def runner():
+    """Provide a Click CLI test runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def mock_client():
+    """Provide a mocked UiPath client with an async agenthub service."""
+    with patch("uipath.platform._uipath.UiPath") as mock:
+        client_instance = MagicMock()
+        mock.return_value = client_instance
+
+        client_instance.agenthub = MagicMock()
+        client_instance.agenthub.get_available_llm_models_async = AsyncMock()
+
+        yield client_instance
+
+
+def _make_models() -> list[LlmModel]:
+    """Build a small list of LlmModel instances."""
+    return [
+        LlmModel(modelName="gpt-4o-mini", vendor="openai"),
+        LlmModel(modelName="claude-sonnet-4-5", vendor="anthropic"),
+    ]
+
+
+class TestListModels:
+    def test_basic(self, runner, mock_client, mock_env_vars):
+        """Default table output lists each model."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list", "models"])
+
+        assert result.exit_code == 0
+        assert "gpt-4o-mini" in result.output
+        assert "claude-sonnet-4-5" in result.output
+        assert "openai" in result.output
+        assert "anthropic" in result.output
+        mock_client.agenthub.get_available_llm_models_async.assert_awaited_once()
+
+    def test_empty(self, runner, mock_client, mock_env_vars):
+        """Empty result prints the formatter's no-results placeholder."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = []
+
+        result = runner.invoke(cli, ["list", "models"])
+
+        assert result.exit_code == 0
+        assert "No results" in result.output
+
+    def test_json_format(self, runner, mock_client, mock_env_vars):
+        """--format json returns parseable JSON with model fields."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list", "models", "--format", "json"])
+
+        assert result.exit_code == 0
+        payload = json.loads(result.output)
+        assert isinstance(payload, list)
+        assert {m["model_name"] for m in payload} == {
+            "gpt-4o-mini",
+            "claude-sonnet-4-5",
+        }
+        assert {m["vendor"] for m in payload} == {"openai", "anthropic"}
+
+    def test_csv_format(self, runner, mock_client, mock_env_vars):
+        """--format csv emits a header row and one row per model."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["list", "models", "--format", "csv"])
+
+        assert result.exit_code == 0
+        lines = [line for line in result.output.splitlines() if line.strip()]
+        # Header + 2 data rows
+        assert len(lines) == 3
+        assert "model_name" in lines[0]
+        assert "vendor" in lines[0]
+        assert any("gpt-4o-mini" in line for line in lines[1:])
+        assert any("claude-sonnet-4-5" in line for line in lines[1:])
+
+    def test_global_format_flag(self, runner, mock_client, mock_env_vars):
+        """Global --format flag on the cli group is honored."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        result = runner.invoke(cli, ["--format", "json", "list", "models"])
+
+        assert result.exit_code == 0
+        payload = json.loads(result.output)
+        assert isinstance(payload, list)
+        assert len(payload) == 2
+
+    def test_output_to_file(self, runner, mock_client, mock_env_vars, tmp_path):
+        """--output writes the formatted result to the given file."""
+        mock_client.agenthub.get_available_llm_models_async.return_value = (
+            _make_models()
+        )
+
+        out_file = tmp_path / "models.json"
+        result = runner.invoke(
+            cli,
+            ["list", "models", "--format", "json", "--output", str(out_file)],
+        )
+
+        assert result.exit_code == 0
+        assert out_file.exists()
+        payload = json.loads(out_file.read_text(encoding="utf-8"))
+        assert {m["model_name"] for m in payload} == {
+            "gpt-4o-mini",
+            "claude-sonnet-4-5",
+        }
+        assert f"Output written to {out_file}" in result.output
+
+    def test_service_error(self, runner, mock_client, mock_env_vars):
+        """Exceptions from the service are turned into click errors."""
+        mock_client.agenthub.get_available_llm_models_async.side_effect = RuntimeError(
+            "boom"
+        )
+
+        result = runner.invoke(cli, ["list", "models"])
+
+        assert result.exit_code != 0
+        assert "boom" in result.output
+
+
+class TestListAuth:
+    def test_missing_url(self, runner, monkeypatch):
+        """Missing UIPATH_URL surfaces an auth-configuration error."""
+        monkeypatch.delenv("UIPATH_URL", raising=False)
+        monkeypatch.setenv("UIPATH_ACCESS_TOKEN", "mock_token")
+
+        result = runner.invoke(cli, ["list", "models"])
+
+        assert result.exit_code != 0
+        assert "UIPATH_URL not configured" in result.output
+
+    def test_missing_token(self, runner, monkeypatch):
+        """Missing UIPATH_ACCESS_TOKEN surfaces an auth-configuration error."""
+        monkeypatch.setenv("UIPATH_URL", "https://cloud.uipath.com/org/tenant")
+        monkeypatch.delenv("UIPATH_ACCESS_TOKEN", raising=False)
+
+        result = runner.invoke(cli, ["list", "models"])
+
+        assert result.exit_code != 0
+        assert "Authentication required" in result.output
+
+
+class TestListDispatch:
+    def test_unknown_resource(self, runner, mock_env_vars):
+        """Unknown resource type produces a click error listing valid types."""
+        result = runner.invoke(cli, ["list", "bogus"])
+
+        assert result.exit_code != 0
+        assert "Invalid resource type: 'bogus'" in result.output
+        assert "models" in result.output
+
+    def test_missing_resource_argument(self, runner):
+        """Omitting the resource argument is a click usage error."""
+        result = runner.invoke(cli, ["list"])
+
+        assert result.exit_code != 0
+        assert "Missing argument" in result.output or "Usage" in result.output
+
+    def test_help_text(self, runner):
+        """--help surfaces the command description and options."""
+        result = runner.invoke(cli, ["list", "--help"])
+
+        assert result.exit_code == 0
+        assert "List available UiPath resources" in result.output
+        assert "--format" in result.output
+        assert "--output" in result.output
+        assert "RESOURCE" in result.output.upper()
+
+    def test_registered_in_cli(self, runner):
+        """The generic list command is wired into the top-level CLI group."""
+        result = runner.invoke(cli, ["--help"])
+
+        assert result.exit_code == 0
+        assert "list" in result.output