uipath 2.1.18__tar.gz → 2.1.21__tar.gz

{uipath-2.1.18 → uipath-2.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.18
+Version: 2.1.21
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.18 → uipath-2.1.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.18"
+version = "2.1.21"
 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.10"

uipath-2.1.21/samples/event-trigger/.python-version

@@ -0,0 +1 @@
+3.13

uipath-2.1.21/samples/event-trigger/README.md

@@ -0,0 +1,128 @@
+# UiPath Coded Agents with Event Triggers
+
+This guide explains how to create Python-based UiPath Coded Agents that respond to event triggers, enabling seamless event-driven agents.
+
+## Overview
+
+UiPath Coded Agents allow you to write automation logic directly in Python while leveraging UiPath's event trigger system. This project demonstrates how to create agents that handle external events from systems like Gmail, Slack, and other connectors.
+
+## How to Set Up UiPath Coded Agents with Event Triggers
+
+### Step 1: Install UiPath Python SDK
+
+1. Open it with your prefered editor
+2. In terminal run:
+```bash
+uv init
+uv add uipath
+uv run uipath new event-agent
+uv run uipath init
+```
+
+### Step 2: Create Your Coded Agent
+
+Create a Python file with your agent logic using the UiPath SDK:
+
+```python
+from dataclasses import dataclass
+from uipath.models import EventArguments
+from uipath import UiPath
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EchoOut:
+    message: dict
+
+# use EventArguments when called by UiPath EventTriggers
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # get the event payload, this will be different from event to event
+    payload = sdk.connections.retrieve_event_payload(input)
+
+    logger.info(f"Received payload: {payload}")
+
+    return EchoOut(payload)
+```
+
+Run `uipath init` again to update the input arguments.
+
+### Step 3: Understanding the Event Flow
+
+When an event trigger fires, UiPath will:
+1. Pass event data through `EventArguments`
+2. Your agent retrieves the full payload using `sdk.connections.retrieve_event_payload(input)`
+3. Process the payload based on your business logic
+4. Return structured output
+
+### Step 4: Publish Your Coded Agent and setup Event Trigger
+
+#### 4.1: Build and Publish
+1. Use `uipath pack` and `uipath publish` to create and publish the package
+2. Create an Orchestrator Automation from the published process
+
+#### 4.2: Access Event Triggers
+1. Log into UiPath Orchestrator
+2. Navigate to **Automations** → **Processes**
+3. Click on your coded workflow process
+
+#### 4.3: Create Event Trigger
+1. Go to the **Triggers** tab
+2. Click **Add Trigger** → **Event Trigger**
+
+#### 4.4: Configure Event Trigger Settings
+1. **Name**: Descriptive name (e.g., "Gmail Event Handler")
+2. **Event Source**: Select connector type:
+   - `uipath-google-gmailcustom` for Gmail
+   - `uipath-slack` for Slack
+   - `uipath-microsoft-outlookcustom` for Outlook
+   - Custom connectors
+3. **Event Type**: Choose specific event:
+   - `EMAIL_RECEIVED` for emails
+   - `MESSAGE_RECEIVED` for chat messages
+   - Custom event types
+4. **Filters**: Optional event filtering criteria
+
+#### 4.5: Map Event to Input Arguments
+The event data will automatically be passed to your `EventArguments` parameter.
+
+#### 4.6: Enable the Trigger
+1. Review configuration
+2. Click **Create** to save
+3. Ensure trigger status is **Enabled**
+
+### Step 5: Test Your Setup
+
+#### 5.1: Trigger Test Events
+- Send test email (Gmail triggers)
+- Post message in Slack (Slack triggers)
+- Perform action matching your event source
+
+#### 5.2: Monitor Execution
+1. Check **Monitoring** → **Jobs** in Orchestrator
+2. View job details and execution logs
+3. Verify your coded agent processed the event correctly
+
+#### 5.3: Debug with Logs
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+    
+    # payload will be a json (dict) specific to your event
+    payload = sdk.connections.retrieve_event_payload(input)
+    logger.info(f"Successfully retrieved payload: {type(payload)}")
+    logger.debug(f"Payload details: {payload}")
+    
+    # Your processing logic here
+    result = process_event(payload)
+    
+    logger.info(f"Event processed successfully: {result}")
+    return EchoOut(result)
+```

uipath-2.1.21/samples/event-trigger/main.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from uipath.models import EventArguments
+from uipath import UiPath
+from uipath.tracing import traced
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EchoOut:
+    message: dict
+
+@traced()
+def handle_slack_event(payload: dict[str, any]) -> EchoOut:
+    """Handle Slack message events"""
+    message = payload['event']['text'] if 'event' in payload and 'text' in payload['event'] else "No message"
+    user = payload['event']['user'] if 'event' in payload and 'user' in payload['event'] else "Unknown user"
+
+    logger.info(f"Slack message from {user}: {message}")
+
+
+# use InputTriggerEventArgs when called by UiPath EventTriggers
+@traced()
+def main(input: EventArguments) -> EchoOut:
+    sdk = UiPath()
+
+    # get the event payload, this will be different from event to event
+    payload = sdk.connections.retrieve_event_payload(input)
+
+    handle_slack_event(payload)
+
+    logger.info(f"Received payload: {payload}")
+
+    return EchoOut(payload)

uipath-2.1.21/samples/event-trigger/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "event-agent"
+version = "0.0.5"
+description = "event-agent"
+authors = [{ name = "John Doe", email = "john.doe@myemail.com" }]
+dependencies = [
+    "uipath>=2.1.18",
+]
+requires-python = ">=3.10"

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_evals/_evaluators/_evaluator_factory.py

@@ -107,6 +107,10 @@ class EvaluatorFactory:
         model = data.get("model", "")
         if not model:
             raise ValueError("LLM evaluator must include 'model' field")
+        if model == "same-as-agent":
+            raise ValueError(
+                "'same-as-agent' model option is not supported by coded agents evaluations. Please select a specific model for the evaluator."
+            )
 
         return LlmAsAJudgeEvaluator.from_params(
             base_params,

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_evals/_models/_evaluation_set.py

@@ -36,6 +36,16 @@ class EvaluationSet(BaseModel):
     createdAt: str
     updatedAt: str
 
+    def extract_selected_evals(self, eval_ids) -> None:
+        selected_evals: list[EvaluationItem] = []
+        for evaluation in self.evaluations:
+            if evaluation.id in eval_ids:
+                selected_evals.append(evaluation)
+                eval_ids.remove(evaluation.id)
+        if len(eval_ids) > 0:
+            raise ValueError("Unknown evaluation ids: {}".format(eval_ids))
+        self.evaluations = selected_evals
+
 
 class EvaluationStatus(IntEnum):
     PENDING = 0

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_evals/evaluation_service.py

@@ -33,6 +33,7 @@ class EvaluationService:
         self,
         entrypoint: Optional[str] = None,
         eval_set_path: Optional[str | Path] = None,
+        eval_ids: Optional[List[str]] = None,
         workers: int = 8,
         report_progress: bool = True,
     ):
@@ -47,10 +48,10 @@ class EvaluationService:
         self.entrypoint, self.eval_set_path = self._resolve_paths(
             entrypoint, eval_set_path
         )
-        self.eval_set = self._load_eval_set()
+        self._eval_set = self._load_eval_set(eval_ids)
         self._evaluators = self._load_evaluators()
-        self.num_workers = workers
-        self.results_lock = asyncio.Lock()
+        self._num_workers = workers
+        self._results_lock = asyncio.Lock()
         self._progress_manager: Optional[EvaluationProgressManager] = None
         self._report_progress = report_progress
         self._progress_reporter: Optional[ProgressReporter] = None
@@ -169,9 +170,9 @@ class EvaluationService:
         if self._report_progress:
             agent_snapshot = self._extract_agent_snapshot()
             self._progress_reporter = ProgressReporter(
-                eval_set_id=self.eval_set.id,
+                eval_set_id=self._eval_set.id,
                 agent_snapshot=agent_snapshot,
-                no_of_evals=len(self.eval_set.evaluations),
+                no_of_evals=len(self._eval_set.evaluations),
                 evaluators=self._evaluators,
             )
 
@@ -215,12 +216,12 @@ class EvaluationService:
 
         # Create results file
         timestamp = datetime.now(timezone.utc).strftime("%M-%H-%d-%m-%Y")
-        eval_set_name = self.eval_set.name
+        eval_set_name = self._eval_set.name
         self.result_file = results_dir / f"eval-{eval_set_name}-{timestamp}.json"
 
         initial_results = EvaluationSetResult(
-            eval_set_id=self.eval_set.id,
-            eval_set_name=self.eval_set.name,
+            eval_set_id=self._eval_set.id,
+            eval_set_name=self._eval_set.name,
             results=[],
             average_score=0.0,
         )
@@ -228,7 +229,7 @@ class EvaluationService:
         with open(self.result_file, "w", encoding="utf-8") as f:
             f.write(initial_results.model_dump_json(indent=2))
 
-    def _load_eval_set(self) -> EvaluationSet:
+    def _load_eval_set(self, eval_ids: Optional[List[str]] = None) -> EvaluationSet:
         """Load the evaluation set from file.
 
         Returns:
@@ -236,13 +237,16 @@ class EvaluationService:
         """
         with open(self.eval_set_path, "r", encoding="utf-8") as f:
             data = json.load(f)
-            return EvaluationSet(**data)
+        eval_set = EvaluationSet(**data)
+        if eval_ids:
+            eval_set.extract_selected_evals(eval_ids)
+        return eval_set
 
     def _load_evaluators(self) -> List[EvaluatorBase]:
         """Load evaluators referenced by the evaluation set."""
         evaluators = []
         evaluators_dir = self.eval_set_path.parent.parent / "evaluators"
-        evaluator_refs = set(self.eval_set.evaluatorRefs)
+        evaluator_refs = set(self._eval_set.evaluatorRefs)
         found_evaluator_ids = set()
 
         # Load evaluators from JSON files
@@ -252,14 +256,9 @@ class EvaluationService:
                 evaluator_id = data.get("id")
 
                 if evaluator_id in evaluator_refs:
-                    try:
-                        evaluator = EvaluatorFactory.create_evaluator(data)
-                        evaluators.append(evaluator)
-                        found_evaluator_ids.add(evaluator_id)
-                    except Exception as e:
-                        console.warning(
-                            f"Failed to create evaluator {evaluator_id}: {str(e)}"
-                        )
+                    evaluator = EvaluatorFactory.create_evaluator(data)
+                    evaluators.append(evaluator)
+                    found_evaluator_ids.add(evaluator_id)
 
         # Check if all referenced evaluators were found
         missing_evaluators = evaluator_refs - found_evaluator_ids
@@ -276,7 +275,7 @@ class EvaluationService:
         Args:
             results: List of evaluation results to write
         """
-        async with self.results_lock:
+        async with self._results_lock:
             # Read current results
             with open(self.result_file, "r", encoding="utf-8") as f:
                 current_results = EvaluationSetResult.model_validate_json(f.read())
@@ -473,11 +472,11 @@ class EvaluationService:
         Args:
             task_queue: The asyncio queue to add tasks to
         """
-        for eval_item in self.eval_set.evaluations:
+        for eval_item in self._eval_set.evaluations:
             await task_queue.put(eval_item.model_dump())
 
         # Add sentinel values to signal workers to stop
-        for _ in range(self.num_workers):
+        for _ in range(self._num_workers):
             await task_queue.put(None)
 
     async def _consumer_task(
@@ -517,7 +516,7 @@ class EvaluationService:
     async def run_evaluation(self) -> None:
         """Run the evaluation set using multiple worker tasks."""
         console.info(
-            f"Starting evaluating {click.style(self.eval_set.name, fg='cyan')} evaluation set..."
+            f"Starting evaluating {click.style(self._eval_set.name, fg='cyan')} evaluation set..."
         )
 
         if self._report_progress and self._progress_reporter:
@@ -526,7 +525,7 @@ class EvaluationService:
         # Prepare items for progress tracker
         progress_items = [
             {"id": eval_item.id, "name": eval_item.name}
-            for eval_item in self.eval_set.evaluations
+            for eval_item in self._eval_set.evaluations
         ]
 
         with console.evaluation_progress(progress_items) as progress_manager:
@@ -539,7 +538,7 @@ class EvaluationService:
             producer = asyncio.create_task(self._producer_task(task_queue))
 
             consumers = []
-            for worker_id in range(self.num_workers):
+            for worker_id in range(self._num_workers):
                 consumer = asyncio.create_task(
                     self._consumer_task(
                         task_queue, worker_id, results_queue, sw_progress_reporter_queue

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_runtime/_runtime.py

@@ -11,6 +11,7 @@ from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from pydantic import BaseModel
 
 from uipath.tracing import LlmOpsHttpExporter
 
@@ -162,9 +163,11 @@ class UiPathRuntime(UiPathBaseRuntime):
                 input_param = params[0]
                 input_type = input_param.annotation
 
-                # Case 2: Class or dataclass parameter
+                # Case 2: Class, dataclass, or Pydantic model parameter
                 if input_type != inspect.Parameter.empty and (
-                    is_dataclass(input_type) or hasattr(input_type, "__annotations__")
+                    is_dataclass(input_type)
+                    or self._is_pydantic_model(input_type)
+                    or hasattr(input_type, "__annotations__")
                 ):
                     try:
                         valid_type = cast(Type[Any], input_type)
@@ -216,7 +219,16 @@ class UiPathRuntime(UiPathBaseRuntime):
         )
 
     def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
-        """Convert a dictionary to either a dataclass or regular class instance."""
+        """Convert a dictionary to either a dataclass, Pydantic model, or regular class instance."""
+        # Handle Pydantic models
+        try:
+            if inspect.isclass(cls) and issubclass(cls, BaseModel):
+                return cast(T, cls.model_validate(data))
+        except TypeError:
+            # issubclass can raise TypeError if cls is not a class
+            pass
+
+        # Handle dataclasses
         if is_dataclass(cls):
             field_types = get_type_hints(cls)
             converted_data = {}
@@ -227,13 +239,17 @@ class UiPathRuntime(UiPathBaseRuntime):
 
                 value = data[field_name]
                 if (
-                    is_dataclass(field_type) or hasattr(field_type, "__annotations__")
+                    is_dataclass(field_type)
+                    or self._is_pydantic_model(field_type)
+                    or hasattr(field_type, "__annotations__")
                 ) and isinstance(value, dict):
                     typed_field = cast(Type[Any], field_type)
                     value = self._convert_to_class(value, typed_field)
                 converted_data[field_name] = value
 
             return cast(T, cls(**converted_data))
+
+        # Handle regular classes
         else:
             sig = inspect.signature(cls.__init__)
             params = sig.parameters
@@ -254,6 +270,7 @@ class UiPathRuntime(UiPathBaseRuntime):
 
                     if (
                         is_dataclass(param_type)
+                        or self._is_pydantic_model(param_type)
                         or hasattr(param_type, "__annotations__")
                     ) and isinstance(value, dict):
                         typed_param = cast(Type[Any], param_type)
@@ -265,22 +282,41 @@ class UiPathRuntime(UiPathBaseRuntime):
 
             return cls(**init_args)
 
+    def _is_pydantic_model(self, cls: Type[Any]) -> bool:
+        """Safely check if a class is a Pydantic model."""
+        try:
+            return inspect.isclass(cls) and issubclass(cls, BaseModel)
+        except TypeError:
+            # issubclass can raise TypeError if cls is not a class
+            return False
+
     def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
-        """Convert a class instance (dataclass or regular) to a dictionary."""
+        """Convert a class instance (dataclass, Pydantic model, or regular) to a dictionary."""
         if obj is None:
             return {}
 
-        if is_dataclass(obj):
+        # Handle Pydantic models
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+
+        # Handle dataclasses
+        elif is_dataclass(obj):
             # Make sure obj is an instance, not a class
             if isinstance(obj, type):
                 return {}
             return asdict(obj)
+
+        # Handle regular classes
         elif hasattr(obj, "__dict__"):
             result = {}
             for key, value in obj.__dict__.items():
                 # Skip private attributes
                 if not key.startswith("_"):
-                    if hasattr(value, "__dict__") or is_dataclass(value):
+                    if (
+                        isinstance(value, BaseModel)
+                        or hasattr(value, "__dict__")
+                        or is_dataclass(value)
+                    ):
                         result[key] = self._convert_from_class(value)
                     else:
                         result[key] = value

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_utils/_input_args.py

@@ -14,6 +14,8 @@ from typing import (
     get_type_hints,
 )
 
+from pydantic import BaseModel
+
 SchemaType = Literal["object", "integer", "double", "string", "boolean", "array"]
 
 TYPE_MAP: Dict[str, SchemaType] = {
@@ -50,7 +52,30 @@ def get_type_schema(type_hint: Any) -> Dict[str, Any]:
         return {"type": "object"}
 
     if inspect.isclass(type_hint):
-        if is_dataclass(type_hint):
+        # Handle Pydantic models
+        if issubclass(type_hint, BaseModel):
+            properties = {}
+            required = []
+
+            # Get the model fields
+            model_fields = type_hint.model_fields
+
+            for field_name, field_info in model_fields.items():
+                # Use alias if defined, otherwise use field name
+                schema_field_name = field_info.alias if field_info.alias else field_name
+
+                # Get the field type schema
+                field_schema = get_type_schema(field_info.annotation)
+                properties[schema_field_name] = field_schema
+
+                # Check if field is required using Pydantic's built-in method
+                if field_info.is_required():
+                    required.append(schema_field_name)
+
+            return {"type": "object", "properties": properties, "required": required}
+
+        # Handle dataclasses
+        elif is_dataclass(type_hint):
             properties = {}
             required = []
 
@@ -61,6 +86,8 @@ def get_type_schema(type_hint: Any) -> Dict[str, Any]:
                     required.append(field.name)
 
             return {"type": "object", "properties": properties, "required": required}
+
+        # Handle regular classes with annotations
         elif hasattr(type_hint, "__annotations__"):
             properties = {}
             required = []

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_utils/_parse_ast.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from ..._services import (
     AssetsService,
     BucketsService,
+    ConnectionsService,
     ContextGroundingService,
     ProcessesService,
 )
@@ -47,6 +48,7 @@ supported_bindings_by_service = {
     "processes": ProcessesService,
     "buckets": BucketsService,
     "context_grounding": ContextGroundingService,
+    "connections": ConnectionsService,
 }
 
 
@@ -103,7 +105,17 @@ class ServiceUsage:
 
         # custom logic for connections bindings
         elif self.service_name == "connections":
+            # First, try to get inferred bindings for connections if they exist
+            connections_service = supported_bindings_by_service.get("connections")
+            inferred_bindings = {}
+            if connections_service:
+                inferred_bindings = get_inferred_bindings_names(connections_service)
+
             for call in self.method_calls:
+                # Skip methods that are decorated with @infer_bindings(ignore=False)
+                if call.method_name in inferred_bindings:
+                    continue
+
                 if len(call.args) > 0:
                     connection_id = call.args[0]
                     if connection_id:

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/_utils/_project_files.py

@@ -68,6 +68,7 @@ def get_project_config(directory: str) -> dict[str, str]:
         "version": toml_data["version"],
         "authors": toml_data["authors"],
         "dependencies": toml_data.get("dependencies", {}),
+        "requires-python": toml_data.get("requires-python", {}),
     }
 
 
@@ -97,6 +98,11 @@ def validate_config(config: dict[str, str]) -> None:
             'Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]'
         )
 
+    if not config["requires-python"] or config["requires-python"].strip() == "":
+        console.error(
+            "'requires-python' field cannot be empty. Please specify it in pyproject.toml:  requires-python = \">=3.10\""
+        )
+
     invalid_chars = ["&", "<", ">", '"', "'", ";"]
     for char in invalid_chars:
         if char in config["project_name"]:
@@ -296,6 +302,7 @@ def read_toml_project(file_path: str) -> dict:
         "version": project["version"].strip(),
         "authors": author_name.strip(),
         "dependencies": dependencies,
+        "requires-python": project.get("requires-python", "").strip(),
     }
 
 

{uipath-2.1.18 → uipath-2.1.21}/src/uipath/_cli/cli_eval.py

@@ -1,7 +1,8 @@
 # type: ignore
+import ast
 import asyncio
 import os
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 
 import click
 from dotenv import load_dotenv
@@ -15,9 +16,18 @@ console = ConsoleLogger()
 load_dotenv(override=True)
 
 
+class LiteralOption(click.Option):
+    def type_cast_value(self, ctx, value):
+        try:
+            return ast.literal_eval(value)
+        except Exception as e:
+            raise click.BadParameter(value) from e
+
+
 def eval_agent(
     entrypoint: Optional[str] = None,
     eval_set: Optional[str] = None,
+    eval_ids: Optional[List[str]] = None,
     workers: int = 8,
     no_report: bool = False,
     **kwargs,
@@ -27,6 +37,7 @@ def eval_agent(
     Args:
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not provided)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not provided)
+        eval_ids: Optional list of evaluation IDs
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
         **kwargs: Additional arguments for future extensibility
@@ -41,8 +52,13 @@ def eval_agent(
         if workers < 1:
             return False, "Number of workers must be at least 1", None
 
+        print("EVAL SET")
+        print(eval_set)
+        if eval_set is not None and len(eval_set) == 0:
+            return False, "Evaluation set must not be empty", None
+
         service = EvaluationService(
-            entrypoint, eval_set, workers, report_progress=not no_report
+            entrypoint, eval_set, eval_ids, workers, report_progress=not no_report
         )
         asyncio.run(service.run_evaluation())
 
@@ -55,6 +71,7 @@ def eval_agent(
 @click.command()
 @click.argument("entrypoint", required=False)
 @click.argument("eval_set", required=False)
+@click.option("--eval-ids", cls=LiteralOption, default="[]")
 @click.option(
     "--no-report",
     is_flag=True,
@@ -69,20 +86,28 @@ def eval_agent(
 )
 @track(when=lambda *_a, **_kw: os.getenv(ENV_JOB_ID) is None)
 def eval(
-    entrypoint: Optional[str], eval_set: Optional[str], no_report: bool, workers: int
+    entrypoint: Optional[str],
+    eval_set: Optional[str],
+    eval_ids: List[str],
+    no_report: bool,
+    workers: int,
 ) -> None:
     """Run an evaluation set against the agent.
 
     Args:
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
+        eval_ids: Optional list of evaluation IDs
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     """
     success, error_message, info_message = eval_agent(
-        entrypoint=entrypoint, eval_set=eval_set, workers=workers, no_report=no_report
+        entrypoint=entrypoint,
+        eval_set=eval_set,
+        eval_ids=eval_ids,
+        workers=workers,
+        no_report=no_report,
     )
-
     if error_message:
         console.error(error_message)
         click.get_current_context().exit(1)