uipath 2.1.70__py3-none-any.whl → 2.1.72__py3-none-any.whl

uipath/_cli/_dev/_terminal/_components/_history.py

@@ -73,13 +73,33 @@ class RunHistoryPanel(Container):
         self.refresh_list()
 
     def _refresh_running_items(self) -> None:
+        """Refresh display names for running items only."""
         if not any(run.status == "running" for run in self.runs):
-            return None  # No running items, skip update
+            return None
 
-        run_list = self.query_one("#run-list", ListView)
+        try:
+            run_list = self.query_one("#run-list", ListView)
+        except Exception:
+            return None
+
+        # Take a snapshot of items to avoid mid-iteration changes
+        items_snapshot = list(run_list.children)
+
+        for item in items_snapshot:
+            if not hasattr(item, "run_id"):
+                continue
+
+            run = self.get_run_by_id(item.run_id)
+            if not run or run.status != "running":
+                continue
+
+            # Check if item still exists in the list (wasn't removed)
+            if item not in run_list.children:
+                continue
 
-        for item in run_list.children:
-            run = self.get_run_by_id(item.run_id)  # type: ignore[attr-defined]
-            if run and run.status == "running":
+            try:
                 static = item.query_one(Static)
                 static.update(run.display_name)
+            except Exception:
+                # Item structure changed or was removed
+                continue

uipath/_cli/_evals/_evaluator_factory.py

@@ -1,5 +1,14 @@
 from typing import Any, Dict
 
+from pydantic import TypeAdapter
+
+from uipath._cli._evals._models._evaluator import (
+    EqualsEvaluatorParams,
+    Evaluator,
+    JsonSimilarityEvaluatorParams,
+    LLMEvaluatorParams,
+    TrajectoryEvaluatorParams,
+)
 from uipath._cli._evals._models._evaluator_base_params import EvaluatorBaseParams
 from uipath.eval.evaluators import (
     BaseEvaluator,
@@ -8,7 +17,6 @@ from uipath.eval.evaluators import (
     LlmAsAJudgeEvaluator,
     TrajectoryEvaluator,
 )
-from uipath.eval.models.models import EvaluatorCategory, EvaluatorType
 
 
 class EvaluatorFactory:
@@ -35,110 +43,64 @@ class EvaluatorFactory:
         if not id:
             raise ValueError("Evaluator configuration must include 'id' field")
 
-        category = EvaluatorCategory.from_int(data.get("category"))
-        evaluator_type = EvaluatorType.from_int(data.get("type", EvaluatorType.Unknown))
-        description = data.get("description", "")
-        created_at = data.get("createdAt", "")
-        updated_at = data.get("updatedAt", "")
-        target_output_key = data.get("targetOutputKey", "")
-
-        # Create base parameters
-        base_params = EvaluatorBaseParams(
-            id=id,
-            category=category,
-            evaluator_type=evaluator_type,
-            name=name,
-            description=description,
-            created_at=created_at,
-            updated_at=updated_at,
-            target_output_key=target_output_key,
-        )
-
-        match category:
-            case EvaluatorCategory.Deterministic:
-                if evaluator_type == evaluator_type.Equals:
-                    return EvaluatorFactory._create_exact_match_evaluator(
-                        base_params, data
-                    )
-                elif evaluator_type == evaluator_type.JsonSimilarity:
-                    return EvaluatorFactory._create_json_similarity_evaluator(
-                        base_params, data
-                    )
-                else:
-                    raise ValueError(
-                        f"Unknown evaluator type {evaluator_type} for category {category}"
-                    )
-            case EvaluatorCategory.LlmAsAJudge:
-                return EvaluatorFactory._create_llm_as_judge_evaluator(
-                    base_params, data
-                )
-            case EvaluatorCategory.AgentScorer:
-                raise NotImplementedError()
-            case EvaluatorCategory.Trajectory:
-                return EvaluatorFactory._create_trajectory_evaluator(base_params, data)
+        params: EvaluatorBaseParams = TypeAdapter(Evaluator).validate_python(data)
+
+        match params:
+            case EqualsEvaluatorParams():
+                return EvaluatorFactory._create_exact_match_evaluator(params)
+            case JsonSimilarityEvaluatorParams():
+                return EvaluatorFactory._create_json_similarity_evaluator(params)
+            case LLMEvaluatorParams():
+                return EvaluatorFactory._create_llm_as_judge_evaluator(params)
+            case TrajectoryEvaluatorParams():
+                return EvaluatorFactory._create_trajectory_evaluator(params)
             case _:
-                raise ValueError(f"Unknown evaluator category: {category}")
+                raise ValueError(f"Unknown evaluator category: {params}")
 
     @staticmethod
     def _create_exact_match_evaluator(
-        base_params: EvaluatorBaseParams, data: Dict[str, Any]
+        params: EqualsEvaluatorParams,
     ) -> ExactMatchEvaluator:
         """Create a deterministic evaluator."""
-        return ExactMatchEvaluator(
-            **base_params.model_dump(),
-        )
+        return ExactMatchEvaluator(**params.model_dump())
 
     @staticmethod
     def _create_json_similarity_evaluator(
-        base_params: EvaluatorBaseParams, data: Dict[str, Any]
+        params: JsonSimilarityEvaluatorParams,
     ) -> JsonSimilarityEvaluator:
         """Create a deterministic evaluator."""
-        return JsonSimilarityEvaluator(
-            **base_params.model_dump(),
-        )
+        return JsonSimilarityEvaluator(**params.model_dump())
 
     @staticmethod
     def _create_llm_as_judge_evaluator(
-        base_params: EvaluatorBaseParams, data: Dict[str, Any]
+        params: LLMEvaluatorParams,
     ) -> LlmAsAJudgeEvaluator:
         """Create an LLM-as-a-judge evaluator."""
-        prompt = data.get("prompt", "")
-        if not prompt:
+        if not params.prompt:
             raise ValueError("LLM evaluator must include 'prompt' field")
 
-        model = data.get("model", "")
-        if not model:
+        if not params.model:
             raise ValueError("LLM evaluator must include 'model' field")
-        if model == "same-as-agent":
+        if params.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(
-            **base_params.model_dump(),
-            prompt=prompt,
-            model=model,
-        )
+        return LlmAsAJudgeEvaluator(**params.model_dump())
 
     @staticmethod
     def _create_trajectory_evaluator(
-        base_params: EvaluatorBaseParams, data: Dict[str, Any]
+        params: TrajectoryEvaluatorParams,
     ) -> TrajectoryEvaluator:
         """Create a trajectory evaluator."""
-        prompt = data.get("prompt", "")
-        if not prompt:
+        if not params.prompt:
             raise ValueError("Trajectory evaluator must include 'prompt' field")
 
-        model = data.get("model", "")
-        if not model:
+        if not params.model:
             raise ValueError("LLM evaluator must include 'model' field")
-        if model == "same-as-agent":
+        if params.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 TrajectoryEvaluator(
-            **base_params.model_dump(),
-            prompt=prompt,
-            model=model,
-        )
+        return TrajectoryEvaluator(**params.model_dump())

uipath/_cli/_evals/_models/_evaluation_set.py

@@ -5,6 +5,10 @@ from pydantic import BaseModel, ConfigDict, Field
 from pydantic.alias_generators import to_camel
 
 
+class EvaluationSimulationTool(BaseModel):
+    name: str = Field(..., alias="name")
+
+
 class EvaluationItem(BaseModel):
     """Individual evaluation item within an evaluation set."""
 
@@ -14,15 +18,19 @@ class EvaluationItem(BaseModel):
     name: str
     inputs: Dict[str, Any]
     expected_output: Dict[str, Any]
-    expected_agent_behavior: str = ""
-    simulation_instructions: str = ""
-    simulate_input: bool = False
-    input_generation_instructions: str = ""
-    simulate_tools: bool = False
-    tools_to_simulate: List[str] = Field(default_factory=list)
-    eval_set_id: str
-    created_at: str
-    updated_at: str
+    expected_agent_behavior: str = Field(default="", alias="expectedAgentBehavior")
+    simulation_instructions: str = Field(default="", alias="simulationInstructions")
+    simulate_input: bool = Field(default=False, alias="simulateInput")
+    input_generation_instructions: str = Field(
+        default="", alias="inputGenerationInstructions"
+    )
+    simulate_tools: bool = Field(default=False, alias="simulateTools")
+    tools_to_simulate: List[EvaluationSimulationTool] = Field(
+        default_factory=list, alias="toolsToSimulate"
+    )
+    eval_set_id: str = Field(alias="evalSetId")
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
 
 
 class EvaluationSet(BaseModel):
@@ -31,15 +39,17 @@ class EvaluationSet(BaseModel):
     model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
 
     id: str
-    file_name: str
+    file_name: str = Field(..., alias="fileName")
     evaluator_refs: List[str] = Field(default_factory=list)
     evaluations: List[EvaluationItem] = Field(default_factory=list)
     name: str
-    batch_size: int = 10
-    timeout_minutes: int = 20
-    model_settings: List[Dict[str, Any]] = Field(default_factory=list)
-    created_at: str
-    updated_at: str
+    batch_size: int = Field(10, alias="batchSize")
+    timeout_minutes: int = Field(default=20, alias="timeoutMinutes")
+    model_settings: List[Dict[str, Any]] = Field(
+        default_factory=list, alias="modelSettings"
+    )
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
 
     def extract_selected_evals(self, eval_ids) -> None:
         selected_evals: list[EvaluationItem] = []

uipath/_cli/_evals/_models/_evaluator.py

@@ -0,0 +1,106 @@
+from typing import Annotated, Any, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
+
+from uipath.eval.models.models import EvaluatorCategory, EvaluatorType
+
+
+class EvaluatorBaseParams(BaseModel):
+    """Parameters for initializing the base evaluator."""
+
+    id: str
+    name: str
+    description: str
+    evaluator_type: EvaluatorType = Field(..., alias="type")
+    created_at: str = Field(..., alias="createdAt")
+    updated_at: str = Field(..., alias="updatedAt")
+    target_output_key: str = Field(..., alias="targetOutputKey")
+    file_name: str = Field(..., alias="fileName")
+
+
+class LLMEvaluatorParams(EvaluatorBaseParams):
+    category: Literal[EvaluatorCategory.LlmAsAJudge] = Field(..., alias="category")
+    prompt: str = Field(..., alias="prompt")
+    model: str = Field(..., alias="model")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class TrajectoryEvaluatorParams(EvaluatorBaseParams):
+    category: Literal[EvaluatorCategory.Trajectory] = Field(..., alias="category")
+    prompt: str = Field(..., alias="prompt")
+    model: str = Field(..., alias="model")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class EqualsEvaluatorParams(EvaluatorBaseParams):
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class JsonSimilarityEvaluatorParams(EvaluatorBaseParams):
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class UnknownEvaluatorParams(EvaluatorBaseParams):
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+def evaluator_discriminator(data: Any) -> str:
+    if isinstance(data, dict):
+        category = data.get("category")
+        evaluator_type = data.get("type")
+        match category:
+            case EvaluatorCategory.LlmAsAJudge:
+                return "LLMEvaluatorParams"
+            case EvaluatorCategory.Trajectory:
+                return "TrajectoryEvaluatorParams"
+            case EvaluatorCategory.Deterministic:
+                match evaluator_type:
+                    case EvaluatorType.Equals:
+                        return "EqualsEvaluatorParams"
+                    case EvaluatorType.JsonSimilarity:
+                        return "JsonSimilarityEvaluatorParams"
+                    case _:
+                        return "UnknownEvaluatorParams"
+            case _:
+                return "UnknownEvaluatorParams"
+    else:
+        return "UnknownEvaluatorParams"
+
+
+Evaluator = Annotated[
+    Union[
+        Annotated[
+            LLMEvaluatorParams,
+            Tag("LLMEvaluatorParams"),
+        ],
+        Annotated[
+            TrajectoryEvaluatorParams,
+            Tag("TrajectoryEvaluatorParams"),
+        ],
+        Annotated[
+            EqualsEvaluatorParams,
+            Tag("EqualsEvaluatorParams"),
+        ],
+        Annotated[
+            JsonSimilarityEvaluatorParams,
+            Tag("JsonSimilarityEvaluatorParams"),
+        ],
+        Annotated[
+            UnknownEvaluatorParams,
+            Tag("UnknownEvaluatorParams"),
+        ],
+    ],
+    Field(discriminator=Discriminator(evaluator_discriminator)),
+]

uipath/_cli/_runtime/_contracts.py

@@ -525,6 +525,7 @@ class UiPathBaseRuntime(ABC):
             dir=self.context.runtime_dir,
             file=self.context.logs_file,
             job_id=self.context.job_id,
+            execution_id=self.context.execution_id,
             is_debug_run=self.is_debug_run(),
             log_handler=self.context.log_handler,
         )

uipath/_cli/_runtime/_logging.py

@@ -1,8 +1,14 @@
 import logging
 import os
 import sys
+from contextvars import ContextVar
 from typing import Optional, TextIO, Union, cast
 
+# Context variable to track current execution_id
+current_execution_id: ContextVar[Optional[str]] = ContextVar(
+    "current_execution_id", default=None
+)
+
 
 class PersistentLogsHandler(logging.FileHandler):
     """A simple log handler that always writes to a single file without rotation."""
@@ -20,6 +26,30 @@ class PersistentLogsHandler(logging.FileHandler):
         self.setFormatter(self.formatter)
 
 
+class ExecutionContextFilter(logging.Filter):
+    """Filter that only allows logs from a specific execution context."""
+
+    def __init__(self, execution_id: str):
+        super().__init__()
+        self.execution_id = execution_id
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Allow logs that have matching execution_id attribute or context."""
+        # First check if record has execution_id attribute
+        record_execution_id = getattr(record, "execution_id", None)
+        if record_execution_id == self.execution_id:
+            return True
+
+        # Fall back to context variable
+        ctx_execution_id = current_execution_id.get()
+        if ctx_execution_id == self.execution_id:
+            # Inject execution_id into record for downstream handlers
+            record.execution_id = self.execution_id
+            return True
+
+        return False
+
+
 class LogsInterceptor:
     """Intercepts all logging and stdout/stderr, routing to either persistent log files or stdout based on whether it's running as a job or not."""
 
@@ -31,6 +61,7 @@ class LogsInterceptor:
         job_id: Optional[str] = None,
         is_debug_run: bool = False,
         log_handler: Optional[logging.Handler] = None,
+        execution_id: Optional[str] = None,
     ):
         """Initialize the log interceptor.
 
@@ -41,9 +72,11 @@ class LogsInterceptor:
             job_id (str, optional): If provided, logs go to file; otherwise, to stdout.
             is_debug_run (bool, optional): If True, log the output to stdout/stderr.
             log_handler (logging.Handler, optional): Custom log handler to use.
+            execution_id (str, optional): Unique identifier for this execution context.
         """
         min_level = min_level or "INFO"
         self.job_id = job_id
+        self.execution_id = execution_id
 
         # Convert to numeric level for consistent comparison
         self.numeric_min_level = getattr(logging, min_level.upper(), logging.INFO)
@@ -81,6 +114,12 @@ class LogsInterceptor:
                 self.log_handler = PersistentLogsHandler(file=log_file)
 
         self.log_handler.setLevel(self.numeric_min_level)
+
+        # Add execution context filter if execution_id provided
+        if execution_id:
+            self.execution_filter = ExecutionContextFilter(execution_id)
+            self.log_handler.addFilter(self.execution_filter)
+
         self.logger = logging.getLogger("runtime")
         self.patched_loggers: set[str] = set()
 
@@ -95,22 +134,37 @@ class LogsInterceptor:
 
     def setup(self) -> None:
         """Configure logging to use our persistent handler."""
-        # Use global disable to prevent all logging below our minimum level
-        if self.numeric_min_level > logging.NOTSET:
+        # Set the context variable for this execution
+        if self.execution_id:
+            current_execution_id.set(self.execution_id)
+
+        # Only use global disable if we're not in a parallel execution context
+        if not self.execution_id and self.numeric_min_level > logging.NOTSET:
             logging.disable(self.numeric_min_level - 1)
 
         # Set root logger level
         self.root_logger.setLevel(self.numeric_min_level)
 
-        # Remove ALL handlers from root logger and add only ours
-        self._clean_all_handlers(self.root_logger)
+        if self.execution_id:
+            # Parallel execution mode: add our handler without removing others
+            if self.log_handler not in self.root_logger.handlers:
+                self.root_logger.addHandler(self.log_handler)
+
+            # Set up propagation for all existing loggers
+            for logger_name in logging.root.manager.loggerDict:
+                logger = logging.getLogger(logger_name)
+                # Keep propagation enabled so logs flow to all handlers
+                self.patched_loggers.add(logger_name)
+        else:
+            # Single execution mode: remove all handlers and add only ours
+            self._clean_all_handlers(self.root_logger)
 
-        # Set up propagation for all existing loggers
-        for logger_name in logging.root.manager.loggerDict:
-            logger = logging.getLogger(logger_name)
-            logger.propagate = False  # Prevent double-logging
-            self._clean_all_handlers(logger)
-            self.patched_loggers.add(logger_name)
+            # Set up propagation for all existing loggers
+            for logger_name in logging.root.manager.loggerDict:
+                logger = logging.getLogger(logger_name)
+                logger.propagate = False  # Prevent double-logging
+                self._clean_all_handlers(logger)
+                self.patched_loggers.add(logger_name)
 
         # Set up stdout/stderr redirection
         self._redirect_stdout_stderr()
@@ -130,7 +184,7 @@ class LogsInterceptor:
                 self.level = level
                 self.min_level = min_level
                 self.buffer = ""
-                self.sys_file = sys_file  # Store reference to system stdout/stderr
+                self.sys_file = sys_file
 
             def write(self, message: str) -> None:
                 self.buffer += message
@@ -138,7 +192,7 @@ class LogsInterceptor:
                     line, self.buffer = self.buffer.split("\n", 1)
                     # Only log if the message is not empty and the level is sufficient
                     if line and self.level >= self.min_level:
-                        # Use _log to avoid potential recursive logging if logging methods are overridden
+                        # The context variable is automatically available here
                         self.logger._log(self.level, line, ())
 
             def flush(self) -> None:
@@ -160,14 +214,21 @@ class LogsInterceptor:
             def writable(self) -> bool:
                 return True
 
-        # Set up stdout and stderr loggers with propagate=False
+        # Set up stdout and stderr loggers
         stdout_logger = logging.getLogger("stdout")
-        stdout_logger.propagate = False
-        self._clean_all_handlers(stdout_logger)
-
         stderr_logger = logging.getLogger("stderr")
+
+        stdout_logger.propagate = False
         stderr_logger.propagate = False
-        self._clean_all_handlers(stderr_logger)
+
+        if self.execution_id:
+            if self.log_handler not in stdout_logger.handlers:
+                stdout_logger.addHandler(self.log_handler)
+            if self.log_handler not in stderr_logger.handlers:
+                stderr_logger.addHandler(self.log_handler)
+        else:
+            self._clean_all_handlers(stdout_logger)
+            self._clean_all_handlers(stderr_logger)
 
         # Use the min_level in the LoggerWriter to filter messages
         sys.stdout = LoggerWriter(
@@ -179,21 +240,41 @@ class LogsInterceptor:
 
     def teardown(self) -> None:
         """Restore original logging configuration."""
-        # Restore the original disable level
-        logging.disable(self.original_disable_level)
-
-        if self.log_handler in self.root_logger.handlers:
-            self.root_logger.removeHandler(self.log_handler)
+        # Clear the context variable
+        if self.execution_id:
+            current_execution_id.set(None)
 
-        for logger_name in self.patched_loggers:
-            logger = logging.getLogger(logger_name)
-            if self.log_handler in logger.handlers:
-                logger.removeHandler(self.log_handler)
-
-        self.root_logger.setLevel(self.original_level)
-        for handler in self.original_handlers:
-            if handler not in self.root_logger.handlers:
-                self.root_logger.addHandler(handler)
+        # Restore the original disable level
+        if not self.execution_id:
+            logging.disable(self.original_disable_level)
+
+        # Remove our handler and filter
+        if self.execution_id:
+            if hasattr(self, "execution_filter"):
+                self.log_handler.removeFilter(self.execution_filter)
+            if self.log_handler in self.root_logger.handlers:
+                self.root_logger.removeHandler(self.log_handler)
+
+            # Remove from stdout/stderr loggers too
+            stdout_logger = logging.getLogger("stdout")
+            stderr_logger = logging.getLogger("stderr")
+            if self.log_handler in stdout_logger.handlers:
+                stdout_logger.removeHandler(self.log_handler)
+            if self.log_handler in stderr_logger.handlers:
+                stderr_logger.removeHandler(self.log_handler)
+        else:
+            if self.log_handler in self.root_logger.handlers:
+                self.root_logger.removeHandler(self.log_handler)
+
+            for logger_name in self.patched_loggers:
+                logger = logging.getLogger(logger_name)
+                if self.log_handler in logger.handlers:
+                    logger.removeHandler(self.log_handler)
+
+            self.root_logger.setLevel(self.original_level)
+            for handler in self.original_handlers:
+                if handler not in self.root_logger.handlers:
+                    self.root_logger.addHandler(handler)
 
         self.log_handler.close()
 

uipath/_cli/cli_pull.py

@@ -112,7 +112,7 @@ async def download_folder_files(
             if local_hash != remote_hash:
                 styled_path = click.style(str(file_path), fg="cyan")
                 console.warning(f"File {styled_path}" + " differs from remote version.")
-                response = click.prompt("Do you want to override it? (y/n)", type=str)
+                response = click.prompt("Do you want to overwrite it? (y/n)", type=str)
                 if response.lower() == "y":
                     with open(local_path, "w", encoding="utf-8", newline="\n") as f:
                         f.write(remote_content)

uipath/_services/context_grounding_service.py

@@ -1,4 +1,5 @@
-from typing import Any, List, Optional, Tuple, Union
+import json
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import httpx
 from pydantic import TypeAdapter
@@ -9,6 +10,11 @@ from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
 from .._utils.constants import (
+    CONFLUENCE_DATA_SOURCE,
+    DROPBOX_DATA_SOURCE,
+    GOOGLE_DRIVE_DATA_SOURCE,
+    LLMV4,
+    ONEDRIVE_DATA_SOURCE,
     ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
 )
 from ..models import IngestionInProgressException
@@ -312,6 +318,122 @@ class ContextGroundingService(FolderContext, BaseService):
 
         return response.json()
 
+    @traced(name="contextgrounding_create_index", run_type="uipath")
+    @infer_bindings(resource_type="index")
+    def create_index(
+        self,
+        name: str,
+        source: Dict[str, Any],
+        description: Optional[str] = None,
+        cron_expression: Optional[str] = None,
+        time_zone_id: Optional[str] = None,
+        advanced_ingestion: Optional[bool] = True,
+        preprocessing_request: Optional[str] = LLMV4,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> ContextGroundingIndex:
+        """Create a new context grounding index.
+
+        Args:
+            name (str): The name of the index to create.
+            source (dict): Source configuration dictionary:
+                - For buckets: type="bucket", bucket_name, folder_path, directory_path="/" (optional), file_type (optional)
+                - For Google Drive: type="google", connection_name, connection_id, leaf_folder_id, directory_path, folder_path, file_type (optional)
+                - For Dropbox: type="dropbox", connection_name, connection_id, directory_path, folder_path, file_type (optional)
+                - For OneDrive: type="onedrive", connection_name, connection_id, leaf_folder_id, directory_path, folder_path, file_type (optional)
+                - For Confluence: type="confluence", connection_name, connection_id, space_id, directory_path, folder_path, file_type (optional)
+            description (Optional[str]): Description of the index.
+            cron_expression (Optional[str]): Cron expression for scheduled indexing (e.g., "0 0 18 ? * 2" for Tuesdays at 6 PM).
+            time_zone_id (Optional[str]): Valid Windows Timezone ID for the cron expression (e.g., "UTC", "Pacific Standard Time", "GTB Standard Time").
+            advanced_ingestion (Optional[bool]): Enable advanced ingestion with preprocessing. Defaults to True.
+            preprocessing_request (Optional[str]): The OData type for preprocessing request. Defaults to LLMV4.
+            folder_key (Optional[str]): The key of the folder where the index will be created.
+            folder_path (Optional[str]): The path of the folder where the index will be created.
+
+        Returns:
+            ContextGroundingIndex: The created index information.
+        """
+        spec = self._create_spec(
+            name=name,
+            description=description,
+            source=source,
+            cron_expression=cron_expression,
+            time_zone_id=time_zone_id,
+            advanced_ingestion=advanced_ingestion
+            if advanced_ingestion is not None
+            else True,
+            preprocessing_request=preprocessing_request or LLMV4,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return ContextGroundingIndex.model_validate(response.json())
+
+    @traced(name="contextgrounding_create_index", run_type="uipath")
+    @infer_bindings(resource_type="index")
+    async def create_index_async(
+        self,
+        name: str,
+        source: Dict[str, Any],
+        description: Optional[str] = None,
+        cron_expression: Optional[str] = None,
+        time_zone_id: Optional[str] = None,
+        advanced_ingestion: Optional[bool] = True,
+        preprocessing_request: Optional[str] = LLMV4,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> ContextGroundingIndex:
+        """Create a new context grounding index.
+
+        Args:
+            name (str): The name of the index to create.
+            source (dict): Source configuration dictionary:
+                - For buckets: type="bucket", bucket_name, folder_path, directory_path="/" (optional), file_type (optional)
+                - For Google Drive: type="google_drive", connection_name, connection_id, leaf_folder_id, directory_path, folder_path, file_type (optional)
+                - For Dropbox: type="dropbox", connection_name, connection_id, directory_path, folder_path, file_type (optional)
+                - For OneDrive: type="onedrive", connection_name, connection_id, leaf_folder_id, directory_path, folder_path, file_type (optional)
+                - For Confluence: type="confluence", connection_name, connection_id, space_id, directory_path, folder_path, file_type (optional)
+            description (Optional[str]): Description of the index.
+            cron_expression (Optional[str]): Cron expression for scheduled indexing (e.g., "0 0 18 ? * 2" for Tuesdays at 6 PM).
+            time_zone_id (Optional[str]): Valid Windows Timezone ID for the cron expression (e.g., "UTC", "Pacific Standard Time", "GTB Standard Time").
+            advanced_ingestion (Optional[bool]): Enable advanced ingestion with preprocessing. Defaults to True.
+            preprocessing_request (Optional[str]): The OData type for preprocessing request. Defaults to LLMV4.
+            folder_key (Optional[str]): The key of the folder where the index will be created.
+            folder_path (Optional[str]): The path of the folder where the index will be created.
+
+        Returns:
+            ContextGroundingIndex: The created index information.
+        """
+        spec = self._create_spec(
+            name=name,
+            description=description,
+            source=source,
+            cron_expression=cron_expression,
+            time_zone_id=time_zone_id,
+            advanced_ingestion=advanced_ingestion
+            if advanced_ingestion is not None
+            else True,
+            preprocessing_request=preprocessing_request or LLMV4,
+            folder_path=folder_path,
+            folder_key=folder_key,
+        )
+
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            content=spec.content,
+            headers=spec.headers,
+        )
+
+        return ContextGroundingIndex.model_validate(response.json())
+
     @traced(name="contextgrounding_search", run_type="uipath")
     def search(
         self,
@@ -575,40 +697,200 @@ class ContextGroundingService(FolderContext, BaseService):
         self,
         name: str,
         description: Optional[str],
-        storage_bucket_name: Optional[str],
-        file_name_glob: Optional[str],
-        storage_bucket_folder_path: Optional[str],
+        source: Dict[str, Any],
+        advanced_ingestion: bool,
+        preprocessing_request: str,
+        cron_expression: Optional[str] = None,
+        time_zone_id: Optional[str] = None,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
     ) -> RequestSpec:
+        """Create request spec for index creation.
+
+        Args:
+            name: Index name
+            description: Index description
+            source: Source configuration dictionary
+            cron_expression: Optional cron expression for scheduled indexing
+            time_zone_id: Optional timezone for cron expression
+            advanced_ingestion: Whether to enable advanced ingestion with preprocessing
+            preprocessing_request: OData type for preprocessing request
+            folder_key: Optional folder key
+            folder_path: Optional folder path
+
+        Returns:
+            RequestSpec for the create index request
+        """
+        source_type = source.get("type", "").lower()
+
         folder_key = self._resolve_folder_key(folder_key, folder_path)
+        file_type = source.get("file_type")
+        file_name_glob = f"**/*.{file_type}" if file_type else "**/*"
+
+        data_source = self._build_data_source(source_type, source, file_name_glob)
+
+        if cron_expression:
+            data_source["indexer"] = {
+                "cronExpression": cron_expression,
+                "timeZoneId": time_zone_id or "UTC",
+            }
+
+        payload = {
+            "name": name,
+            "description": description or "",
+            "dataSource": data_source,
+        }
+
+        if advanced_ingestion and preprocessing_request:
+            payload["preProcessing"] = {
+                "@odata.type": preprocessing_request,
+            }
 
-        storage_bucket_folder_path = (
-            storage_bucket_folder_path
-            if storage_bucket_folder_path
-            else self._folder_path
-        )
         return RequestSpec(
             method="POST",
             endpoint=Endpoint("/ecs_/v2/indexes/create"),
-            json={
-                "name": name,
-                "description": description,
-                "dataSource": {
-                    "@odata.type": ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
-                    "folder": storage_bucket_folder_path,
-                    "bucketName": storage_bucket_name,
-                    "fileNameGlob": file_name_glob
-                    if file_name_glob is not None
-                    else "*",
-                    "directoryPath": "/",
-                },
-            },
+            content=json.dumps(payload),
             headers={
                 **header_folder(folder_key, None),
+                "Content-Type": "application/json",
             },
         )
 
+    def _build_data_source(
+        self, source_type: str, source: Dict[str, Any], file_name_glob: str
+    ) -> Dict[str, Any]:
+        """Build data source configuration based on type."""
+        if source_type == "bucket":
+            return self._build_bucket_data_source(source, file_name_glob)
+        elif source_type in ["google_drive"]:
+            return self._build_google_drive_data_source(source, file_name_glob)
+        elif source_type == "dropbox":
+            return self._build_dropbox_data_source(source, file_name_glob)
+        elif source_type == "onedrive":
+            return self._build_onedrive_data_source(source, file_name_glob)
+        elif source_type == "confluence":
+            return self._build_confluence_data_source(source, file_name_glob)
+        else:
+            raise ValueError(
+                f"Unsupported data source type: {source_type}. "
+                f"Supported types: bucket, google_drive, dropbox, onedrive, confluence"
+            )
+
+    def _build_bucket_data_source(
+        self, source: Dict[str, Any], file_name_glob: str
+    ) -> Dict[str, Any]:
+        """Build data source configuration for storage bucket."""
+        required_fields = ["bucket_name", "folder_path"]
+        for field in required_fields:
+            if not source.get(field):
+                raise ValueError(f"{field} is required for bucket data source")
+
+        return {
+            "@odata.type": ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE,
+            "folder": source["folder_path"],
+            "bucketName": source["bucket_name"],
+            "fileNameGlob": file_name_glob,
+            "directoryPath": source.get("directory_path", "/"),
+        }
+
+    def _build_google_drive_data_source(
+        self, source: Dict[str, Any], file_name_glob: str
+    ) -> Dict[str, Any]:
+        """Build data source configuration for Google Drive."""
+        required_fields = [
+            "connection_id",
+            "connection_name",
+            "leaf_folder_id",
+            "directory_path",
+            "folder_path",
+        ]
+        for field in required_fields:
+            if not source.get(field):
+                raise ValueError(f"{field} is required for Google Drive data source")
+
+        return {
+            "@odata.type": GOOGLE_DRIVE_DATA_SOURCE,
+            "folder": source["folder_path"],
+            "connectionId": source["connection_id"],
+            "connectionName": source["connection_name"],
+            "leafFolderId": source["leaf_folder_id"],
+            "directoryPath": source["directory_path"],
+            "fileNameGlob": file_name_glob,
+        }
+
+    def _build_dropbox_data_source(
+        self, source: Dict[str, Any], file_name_glob: str
+    ) -> Dict[str, Any]:
+        """Build data source configuration for Dropbox."""
+        required_fields = [
+            "connection_id",
+            "connection_name",
+            "directory_path",
+            "folder_path",
+        ]
+        for field in required_fields:
+            if not source.get(field):
+                raise ValueError(f"{field} is required for Dropbox data source")
+
+        return {
+            "@odata.type": DROPBOX_DATA_SOURCE,
+            "folder": source["folder_path"],
+            "connectionId": source["connection_id"],
+            "connectionName": source["connection_name"],
+            "directoryPath": source["directory_path"],
+            "fileNameGlob": file_name_glob,
+        }
+
+    def _build_onedrive_data_source(
+        self, source: Dict[str, Any], file_name_glob: str
+    ) -> Dict[str, Any]:
+        """Build data source configuration for OneDrive."""
+        required_fields = [
+            "connection_id",
+            "connection_name",
+            "leaf_folder_id",
+            "directory_path",
+            "folder_path",
+        ]
+        for field in required_fields:
+            if not source.get(field):
+                raise ValueError(f"{field} is required for OneDrive data source")
+
+        return {
+            "@odata.type": ONEDRIVE_DATA_SOURCE,
+            "folder": source["folder_path"],
+            "connectionId": source["connection_id"],
+            "connectionName": source["connection_name"],
+            "leafFolderId": source["leaf_folder_id"],
+            "directoryPath": source["directory_path"],
+            "fileNameGlob": file_name_glob,
+        }
+
+    def _build_confluence_data_source(
+        self, source: Dict[str, Any], file_name_glob: str
+    ) -> Dict[str, Any]:
+        """Build data source configuration for Confluence."""
+        required_fields = [
+            "connection_id",
+            "connection_name",
+            "directory_path",
+            "folder_path",
+            "space_id",
+        ]
+        for field in required_fields:
+            if not source.get(field):
+                raise ValueError(f"{field} is required for Confluence data source")
+
+        return {
+            "@odata.type": CONFLUENCE_DATA_SOURCE,
+            "folder": source["folder_path"],
+            "connectionId": source["connection_id"],
+            "connectionName": source["connection_name"],
+            "directoryPath": source["directory_path"],
+            "fileNameGlob": file_name_glob,
+            "spaceId": source["space_id"],
+        }
+
     def _retrieve_by_id_spec(
         self,
         id: str,

uipath/_utils/constants.py

@@ -25,6 +25,18 @@ HEADER_SW_LOCK_KEY = "x-uipath-sw-lockkey"
 ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE = (
     "#UiPath.Vdbs.Domain.Api.V20Models.StorageBucketDataSourceRequest"
 )
+CONFLUENCE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.ConfluenceDataSourceRequest"
+DROPBOX_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.DropboxDataSourceRequest"
+GOOGLE_DRIVE_DATA_SOURCE = (
+    "#UiPath.Vdbs.Domain.Api.V20Models.GoogleDriveDataSourceRequest"
+)
+ONEDRIVE_DATA_SOURCE = "#UiPath.Vdbs.Domain.Api.V20Models.OneDriveDataSourceRequest"
+
+# Preprocessing request types
+LLMV3Mini = "#UiPath.Vdbs.Domain.Api.V20Models.LLMV3MiniPreProcessingRequest"
+LLMV4 = "#UiPath.Vdbs.Domain.Api.V20Models.LLMV4PreProcessingRequest"
+NativeV1 = "#UiPath.Vdbs.Domain.Api.V20Models.NativeV1PreProcessingRequest"
+
 
 # Local storage
 TEMP_ATTACHMENTS_FOLDER = "uipath_attachments"

uipath/agent/_utils.py

@@ -31,6 +31,52 @@ async def load_agent_definition(project_id: str):
         await get_file(project_structure, PurePath("agent.json"), studio_client)
     ).json()
 
+    evaluators = []
+    try:
+        evaluators_path = resolve_path(
+            project_structure, PurePath("evals", "evaluators")
+        )
+        if isinstance(evaluators_path, ProjectFolder):
+            for file in evaluators_path.files:
+                evaluators.append(
+                    (
+                        await get_file(
+                            evaluators_path, PurePath(file.name), studio_client
+                        )
+                    ).json()
+                )
+        else:
+            logger.warning(
+                "Unable to read evaluators from project. Defaulting to empty evaluators."
+            )
+    except Exception:
+        logger.warning(
+            "Unable to read evaluators from project. Defaulting to empty evaluators."
+        )
+
+    evaluation_sets = []
+    try:
+        evaluation_sets_path = resolve_path(
+            project_structure, PurePath("evals", "eval-sets")
+        )
+        if isinstance(evaluation_sets_path, ProjectFolder):
+            for file in evaluation_sets_path.files:
+                evaluation_sets.append(
+                    (
+                        await get_file(
+                            evaluation_sets_path, PurePath(file.name), studio_client
+                        )
+                    ).json()
+                )
+        else:
+            logger.warning(
+                "Unable to read eval-sets from project. Defaulting to empty eval-sets."
+            )
+    except Exception:
+        logger.warning(
+            "Unable to read eval-sets from project. Defaulting to empty eval-sets."
+        )
+
     resolved_path = resolve_path(project_structure, PurePath("resources"))
     if isinstance(resolved_path, ProjectFolder):
         resource_folders = resolved_path.folders
@@ -50,6 +96,8 @@ async def load_agent_definition(project_id: str):
         "id": project_id,
         "name": project_structure.name,
         "resources": resources,
+        "evaluators": evaluators,
+        "evaluationSets": evaluation_sets,
         **agent,
     }
     return TypeAdapter(AgentDefinition).validate_python(agent_definition)

uipath/agent/models/agent.py

@@ -5,6 +5,8 @@ from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
 
+from uipath._cli._evals._models._evaluation_set import EvaluationSet
+from uipath._cli._evals._models._evaluator import Evaluator
 from uipath.models import Connection
 
 
@@ -307,6 +309,14 @@ class BaseAgentDefinition(BaseModel):
     resources: List[AgentResourceConfig] = Field(
         ..., description="List of tools, context, and escalation resources"
     )
+    evaluation_sets: Optional[List[EvaluationSet]] = Field(
+        None,
+        alias="evaluationSets",
+        description="List of agent evaluation sets",
+    )
+    evaluators: Optional[List[Evaluator]] = Field(
+        None, description="List of agent evaluators"
+    )
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"

{uipath-2.1.70.dist-info → uipath-2.1.72.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.70
+Version: 2.1.72
 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.70.dist-info → uipath-2.1.72.dist-info}/RECORD

@@ -15,7 +15,7 @@ uipath/_cli/cli_invoke.py,sha256=m-te-EjhDpk_fhFDkt-yQFzmjEHGo5lQDGEQWxSXisQ,439
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
 uipath/_cli/cli_pack.py,sha256=NmwZTfwZ2fURiHyiX1BM0juAtBOjPB1Jmcpu-rD7p-4,11025
 uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,6471
-uipath/_cli/cli_pull.py,sha256=vwS0KMX6O2L6RaPy8tw_qzXe4dC7kf_G6nbLm0I62eI,6831
+uipath/_cli/cli_pull.py,sha256=PZ2hkfsfN-ElNa3FHjNetTux8XH03tDY5kWWqydQ2OY,6832
 uipath/_cli/cli_push.py,sha256=-j-gDIbT8GyU2SybLQqFl5L8KI9nu3CDijVtltDgX20,3132
 uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
 uipath/_cli/middlewares.py,sha256=GvMhDnx1BmA7rIe12s6Uqv1JdqNZhvraU0a91oqGag4,4976
@@ -35,7 +35,7 @@ uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz
 uipath/_cli/_dev/_terminal/__init__.py,sha256=di_RiN9Mcp9wqyKRRqXag28vbSw8_78mCnQZNn9H-Ss,14027
 uipath/_cli/_dev/_terminal/_components/_chat.py,sha256=NLRoy49QScHiI-q0FGykkaU8ajv1d23fx7issSALcFA,4119
 uipath/_cli/_dev/_terminal/_components/_details.py,sha256=FbLYtJ56gqHV6CIrpzO_n9Sk_YNg4nzRKTSsbj-DBPQ,17257
-uipath/_cli/_dev/_terminal/_components/_history.py,sha256=dcT9tohEwpUaLGi7VWu5d-mDIF45UxFzN2Yvdf5N-eM,2691
+uipath/_cli/_dev/_terminal/_components/_history.py,sha256=QX9GWiKpP1H6_wVOJkrIMb-8w2HKg8g-kcbwxiEQj2s,3237
 uipath/_cli/_dev/_terminal/_components/_json_input.py,sha256=MPkaeiA5KfkwJZKuNJ02hQksVtluZlmJv9nLRRAWYQI,592
 uipath/_cli/_dev/_terminal/_components/_new.py,sha256=paA8oRhP5mphpf3RHV0gx7_CYdN5e6158tv_XVQifdE,5219
 uipath/_cli/_dev/_terminal/_models/_execution.py,sha256=gPcxtwWR9eO929VaieOdI1e77clceKLoKA0FYayuCFQ,2869
@@ -44,19 +44,20 @@ uipath/_cli/_dev/_terminal/_styles/terminal.tcss,sha256=ktVpKwXIXw2VZp8KIZD6fO9i
 uipath/_cli/_dev/_terminal/_utils/_chat.py,sha256=YUZxYVdmEManwHDuZsczJT1dWIYE1dVBgABlurwMFcE,8493
 uipath/_cli/_dev/_terminal/_utils/_exporter.py,sha256=oI6D_eMwrh_2aqDYUh4GrJg8VLGrLYhDahR-_o0uJns,4144
 uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=_ipTl_oAiMF9I7keGt2AAFAMz40DNLVMVkoiq-07UAU,2943
-uipath/_cli/_evals/_evaluator_factory.py,sha256=OWfLxPOEcDn4qv5m3n7LBfIBKcdTPml2ZCLcsqSymlU,5329
+uipath/_cli/_evals/_evaluator_factory.py,sha256=Gycv94VtGOpMir_Gba-UoiAyrSRfbSfe8_pTfjzcA9Q,3875
 uipath/_cli/_evals/_progress_reporter.py,sha256=hpSt0CXpIoFJGsbqZkqmwyGO_TBNesbWKlvDJUEDxd8,16455
 uipath/_cli/_evals/_runtime.py,sha256=WKcBT6DGzNRjgEOpmH0b7RoEbEsHMyAbcAMs8b_CAI0,11418
-uipath/_cli/_evals/_models/_evaluation_set.py,sha256=mwcTstHuyHd7ys_nLzgCNKBAsS4ns9UL2TF5Oq2Cc64,1758
+uipath/_cli/_evals/_models/_evaluation_set.py,sha256=RRDaP0X4E8kueL0Io9yB4y8akx3gKZhoSIgTNhgoN9Y,2407
+uipath/_cli/_evals/_models/_evaluator.py,sha256=fuC3UOYwPD4d_wdynHeLSCzbu82golNAnnPnxC8Y4rk,3315
 uipath/_cli/_evals/_models/_evaluator_base_params.py,sha256=lTYKOV66tcjW85KHTyOdtF1p1VDaBNemrMAvH8bFIFc,382
 uipath/_cli/_evals/_models/_output.py,sha256=LjwMBGI78sDFa2Dl8b9ReXJmjig57pdLWpuiwChrRLo,3096
 uipath/_cli/_evals/_models/_sw_reporting.py,sha256=tSBLQFAdOIun8eP0vsqt56K6bmCZz_uMaWI3hskg_24,536
 uipath/_cli/_evals/_models/_trajectory_span.py,sha256=8ukM8sB9rvzBMHfC_gnexAC3xlp4uMDevKZrRzcgrm4,3637
 uipath/_cli/_push/sw_file_handler.py,sha256=iE8Sk1Z-9hxmLFFj3j-k4kTK6TzNFP6hUCmxTudG6JQ,18251
-uipath/_cli/_runtime/_contracts.py,sha256=xIcKq0xRbenzmJkZQO8blKwZ3b72Ntm4YONSYwaI-kg,28880
+uipath/_cli/_runtime/_contracts.py,sha256=D57cq5V5CZ9p13n_vRDHRcwyJYQUcJLlAMbAOzIiBNI,28932
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
-uipath/_cli/_runtime/_logging.py,sha256=MGklGKPjYKjs7J5Jy9eplA9zCDsdtEbkZdCbTwgut_4,8311
+uipath/_cli/_runtime/_logging.py,sha256=iO0AG_tqUBp7aJZTK_ZgwV3fFvxbi9Rp1UOBn3F76lw,11684
 uipath/_cli/_runtime/_runtime.py,sha256=gby9-avNNlEATEfSXtY8FfJ8nREsSCGA4wMgDlSXTDE,2297
 uipath/_cli/_runtime/_script_executor.py,sha256=PjbmEbyCMofGH2F85b8RFsxdV3Tqw0kVqdWOOk2ZLlI,9687
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
@@ -89,7 +90,7 @@ uipath/_services/assets_service.py,sha256=pG0Io--SeiRRQmfUWPQPl1vq3csZlQgx30LBNK
 uipath/_services/attachments_service.py,sha256=NPQYK7CGjfBaNT_1S5vEAfODmOChTbQZforllFM2ofU,26678
 uipath/_services/buckets_service.py,sha256=5s8tuivd7GUZYj774DDUYTa0axxlUuesc4EBY1V5sdk,18496
 uipath/_services/connections_service.py,sha256=Gt8zPY4oA7cMYAU2LI3lBieoBpV81BOGelnzDWJl_V4,7931
-uipath/_services/context_grounding_service.py,sha256=kp7h6Hd-VUuTqiDO-G7IanmXhaq0XHjXUk0ISFev-5c,24835
+uipath/_services/context_grounding_service.py,sha256=Pjx-QQQEiSKD-hY6ityj3QUSALN3fIcKLLHr_NZ0d_g,37117
 uipath/_services/documents_service.py,sha256=UnFS8EpOZ_Ng2TZk3OiJJ3iNANvFs7QxuoG_v-lQj6c,24815
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
@@ -107,8 +108,8 @@ uipath/_utils/_request_spec.py,sha256=iCtBLqtbWUpFG5g1wtIZBzSupKsfaRLiQFoFc_4B70
 uipath/_utils/_ssl_context.py,sha256=xSYitos0eJc9cPHzNtHISX9PBvL6D2vas5G_GiBdLp8,1783
 uipath/_utils/_url.py,sha256=-4eluSrIZCUlnQ3qU17WPJkgaC2KwF9W5NeqGnTNGGo,2512
 uipath/_utils/_user_agent.py,sha256=pVJkFYacGwaQBomfwWVAvBQgdBUo62e4n3-fLIajWUU,563
-uipath/_utils/constants.py,sha256=defPi1_4sLojgKVsbdIjkfME8O8n-iLmJnj_-n4Ox8s,1108
-uipath/agent/_utils.py,sha256=Z5x7TprkEudrd_aC9YI5ObyT8O05_WkmBJTpqkQKOGQ,1641
+uipath/_utils/constants.py,sha256=2xLT-1aW0aJS2USeZbK-7zRgyyi1bgV60L0rtQOUqOM,1721
+uipath/agent/_utils.py,sha256=frpg3LYJofdGWS5w44PsBaNHiW9GRkLokvNnf2D4a54,3309
 uipath/agent/conversation/__init__.py,sha256=5hK-Iz131mnd9m6ANnpZZffxXZLVFDQ9GTg5z9ik1oQ,5265
 uipath/agent/conversation/async_stream.py,sha256=BA_8uU1DgE3VpU2KkJj0rkI3bAHLk_ZJKsajR0ipMpo,2055
 uipath/agent/conversation/citation.py,sha256=42dGv-wiYx3Lt7MPuPCFTkjAlSADFSzjyNXuZHdxqvo,2253
@@ -119,7 +120,7 @@ uipath/agent/conversation/exchange.py,sha256=nuk1tEMBHc_skrraT17d8U6AtyJ3h07ExGQ
 uipath/agent/conversation/message.py,sha256=1ZkEs146s79TrOAWCQwzBAEJvjAu4lQBpJ64tKXDgGE,2142
 uipath/agent/conversation/meta.py,sha256=3t0eS9UHoAPHre97QTUeVbjDhnMX4zj4-qG6ju0B8wY,315
 uipath/agent/conversation/tool.py,sha256=ol8XI8AVd-QNn5auXNBPcCzOkh9PPFtL7hTK3kqInkU,2191
-uipath/agent/models/agent.py,sha256=HVdv-VHV98ZI4afIxexPDSKEKzGlMJ7uSRLj7qLe6vA,12548
+uipath/agent/models/agent.py,sha256=ie_N47K-txv9Q9kXeynI1FsO2l120JYmjPXNm-e6yMo,12952
 uipath/eval/_helpers/__init__.py,sha256=GSmZMryjuO3Wo_zdxZdrHCRRsgOxsVFYkYgJ15YNC3E,86
 uipath/eval/_helpers/helpers.py,sha256=iE2HHdMiAdAMLqxHkPKHpfecEtAuN5BTBqvKFTI8ciE,1315
 uipath/eval/evaluators/__init__.py,sha256=DJAAhgv0I5UfBod4sGnSiKerfrz1iMmk7GNFb71V8eI,494
@@ -158,8 +159,8 @@ uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,199
 uipath/tracing/_utils.py,sha256=qd7N56tg6VXQ9pREh61esBgUWLNA0ssKsE0QlwrRWFM,11974
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.70.dist-info/METADATA,sha256=Psv1JkySYItSXLqXbmXX2QBnKgVHtESV3-dEiKtCVEc,6482
-uipath-2.1.70.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.70.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.70.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.70.dist-info/RECORD,,
+uipath-2.1.72.dist-info/METADATA,sha256=sIUVm86o9y3uorIq58WEe4g-58aQ_tD0mp_8TPcrhHc,6482
+uipath-2.1.72.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.72.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.72.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.72.dist-info/RECORD,,