uipath 2.1.76__py3-none-any.whl → 2.1.78__py3-none-any.whl

uipath/_cli/_evals/_models/_evaluation_set.py

@@ -19,39 +19,31 @@ class BaseMockingStrategy(BaseModel):
     pass
 
 
+class ModelSettings(BaseModel):
+    """Model Generation Parameters."""
+
+    model: str = Field(..., alias="model")
+    temperature: Optional[float] = Field(default=None, alias="temperature")
+    top_p: Optional[float] = Field(default=None, alias="topP")
+    top_k: Optional[int] = Field(default=None, alias="topK")
+    frequency_penalty: Optional[float] = Field(default=None, alias="frequencyPenalty")
+    presence_penalty: Optional[float] = Field(default=None, alias="presencePenalty")
+    max_tokens: Optional[int] = Field(default=None, alias="maxTokens")
+
+
 class LLMMockingStrategy(BaseMockingStrategy):
     type: Literal[MockingStrategyType.LLM] = MockingStrategyType.LLM
     prompt: str = Field(..., alias="prompt")
     tools_to_simulate: list[EvaluationSimulationTool] = Field(
         ..., alias="toolsToSimulate"
     )
+    model: Optional[ModelSettings] = Field(None, alias="model")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
-"""
-{
-            "function": "postprocess",
-            "arguments": {
-              "args": [],
-              "kwargs": {"x": 3}
-            },
-            "then": [
-              {
-                "return": 3
-              },
-              {
-                "raise": {
-                  "__target__": "NotImplementedError"
-                }
-              }
-            ]
-          }
-          """
-
-
 class MockingArgument(BaseModel):
     args: List[Any] = Field(default_factory=lambda: [], alias="args")
     kwargs: Dict[str, Any] = Field(default_factory=lambda: {}, alias="kwargs")
@@ -99,18 +91,6 @@ class UnknownMockingStrategy(BaseMockingStrategy):
 MockingStrategy = Union[KnownMockingStrategy, UnknownMockingStrategy]
 
 
-def migrate_mocking_strategy(data) -> MockingStrategy:
-    if data.get("simulate_tools") and "tools_to_simulate" in data:
-        return LLMMockingStrategy(
-            **{
-                "prompt": data["simulation_instructions"],
-                "toolsToSimulate": data["tools_to_simulate"],
-            }
-        )
-    else:
-        return UnknownMockingStrategy(type=MockingStrategyType.UNKNOWN)
-
-
 class EvaluationItem(BaseModel):
     """Individual evaluation item within an evaluation set."""
 

uipath/_cli/_evals/_models/_mocks.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+
+class ExampleCall(BaseModel):
+    """Example invocation for a resource."""
+
+    id: str = Field(..., alias="id")
+    input: str = Field(..., alias="input")
+    output: str = Field(..., alias="output")

uipath/_cli/_evals/mocks/llm_mocker.py

@@ -6,11 +6,18 @@ from typing import Any, Callable
 
 from pydantic import BaseModel
 
-from uipath._cli._evals._models._evaluation_set import (
+from .._models._evaluation_set import (
     EvaluationItem,
     LLMMockingStrategy,
 )
-from uipath._cli._evals.mocks.mocker import Mocker, R, T, UiPathMockingNoMatcherError
+from .._models._mocks import ExampleCall
+from .mocker import (
+    Mocker,
+    R,
+    T,
+    UiPathMockResponseGenerationError,
+    UiPathNoMockFoundError,
+)
 
 PROMPT = """You are simulating a tool call for automated testing purposes of an Agent.
 Your task is to provide a realistic response for the tool based on its schema, examples, and context.
@@ -102,8 +109,15 @@ class LLMMocker(Mocker):
                 },
             }
             try:
+                # Safely pull examples from params.
+                example_calls = params.get("example_calls", [])
+                if not isinstance(example_calls, list):
+                    example_calls = []
+                example_calls = [
+                    call for call in example_calls if isinstance(call, ExampleCall)
+                ]
                 prompt_input: dict[str, Any] = {
-                    "toolRunExamples": [],  # Taken from history. Contains id, input json, output json
+                    "toolRunExamples": example_calls,
                     "testRunHistory": [],  # This should contain ordered spans.
                     "toolInfo": {
                         "name": function_name,
@@ -132,6 +146,12 @@ class LLMMocker(Mocker):
                     k: json.dumps(pydantic_to_dict_safe(v))
                     for k, v in prompt_input.items()
                 }
+                model_parameters = self.evaluation_item.mocking_strategy.model
+                completion_kwargs = (
+                    model_parameters.model_dump(by_alias=False, exclude_none=True)
+                    if model_parameters
+                    else {}
+                )
                 response = await llm.chat_completions(
                     [
                         {
@@ -140,14 +160,13 @@ class LLMMocker(Mocker):
                         },
                     ],
                     response_format=response_format,
+                    **completion_kwargs,
                 )
                 mocked_response = OutputSchema(
                     **json.loads(response.choices[0].message.content)
                 )
-                return mocked_response.response
-            except Exception:
-                raise
+                return mocked_response.model_dump(mode="json")["response"]
+            except Exception as e:
+                raise UiPathMockResponseGenerationError() from e
         else:
-            raise UiPathMockingNoMatcherError(
-                f"Method '{function_name}' is not simulated."
-            )
+            raise UiPathNoMockFoundError(f"Method '{function_name}' is not simulated.")

uipath/_cli/_evals/mocks/mocker.py

@@ -23,7 +23,13 @@ class Mocker(ABC):
         raise NotImplementedError()
 
 
-class UiPathMockingNoMatcherError(Exception):
-    """Exception when a mocker is unable to find a match with the invocation."""
+class UiPathNoMockFoundError(Exception):
+    """Exception when a mocker is unable to find a match with the invocation. This is a signal to invoke the real function."""
+
+    pass
+
+
+class UiPathMockResponseGenerationError(Exception):
+    """Exception when a mocker is configured unable to generate a response."""
 
     pass

uipath/_cli/_evals/mocks/mockito_mocker.py

@@ -13,7 +13,13 @@ from uipath._cli._evals._models._evaluation_set import (
     MockingAnswerType,
     MockitoMockingStrategy,
 )
-from uipath._cli._evals.mocks.mocker import Mocker, R, T
+from uipath._cli._evals.mocks.mocker import (
+    Mocker,
+    R,
+    T,
+    UiPathMockResponseGenerationError,
+    UiPathNoMockFoundError,
+)
 
 
 class Stub:
@@ -59,4 +65,16 @@ class MockitoMocker(Mocker):
         self, func: Callable[[T], R], params: dict[str, Any], *args: T, **kwargs
     ) -> R:
         """Respond with mocked response."""
-        return getattr(self.stub, params["name"])(*args, **kwargs)
+        if not isinstance(
+            self.evaluation_item.mocking_strategy, MockitoMockingStrategy
+        ):
+            raise UiPathMockResponseGenerationError("Mocking strategy misconfigured.")
+        if not any(
+            behavior.function == params["name"]
+            for behavior in self.evaluation_item.mocking_strategy.behaviors
+        ):
+            raise UiPathNoMockFoundError()
+        try:
+            return getattr(self.stub, params["name"])(*args, **kwargs)
+        except Exception as e:
+            raise UiPathMockResponseGenerationError() from e

uipath/_cli/_evals/mocks/mocks.py

@@ -1,18 +1,11 @@
 """Mocking interface."""
 
-import asyncio
-import functools
-import inspect
 import logging
-import threading
 from contextvars import ContextVar
 from typing import Any, Callable, Optional
 
-from pydantic import TypeAdapter
-from pydantic_function_models import ValidatedFunction  # type: ignore[import-untyped]
-
 from uipath._cli._evals._models._evaluation_set import EvaluationItem
-from uipath._cli._evals.mocks.mocker import Mocker
+from uipath._cli._evals.mocks.mocker import Mocker, UiPathNoMockFoundError
 from uipath._cli._evals.mocks.mocker_factory import MockerFactory
 
 evaluation_context: ContextVar[Optional[EvaluationItem]] = ContextVar(
@@ -21,12 +14,17 @@ evaluation_context: ContextVar[Optional[EvaluationItem]] = ContextVar(
 
 mocker_context: ContextVar[Optional[Mocker]] = ContextVar("mocker", default=None)
 
+logger = logging.getLogger(__name__)
+
 
 def set_evaluation_item(item: EvaluationItem) -> None:
     """Set an evaluation item within an evaluation set."""
     evaluation_context.set(item)
     try:
-        mocker_context.set(MockerFactory.create(item))
+        if item.mocking_strategy:
+            mocker_context.set(MockerFactory.create(item))
+        else:
+            mocker_context.set(None)
     except Exception:
         logger.warning(f"Failed to create mocker for evaluation {item.name}")
         mocker_context.set(None)
@@ -37,100 +35,7 @@ async def get_mocked_response(
 ) -> Any:
     """Get a mocked response."""
     mocker = mocker_context.get()
-    evaluation_item = evaluation_context.get()
-    if mocker is None or evaluation_item is None:
-        # TODO raise a new UiPath exception type
-        raise RuntimeError(f"Evaluation item {func.__name__} has not been evaluated")
+    if mocker is None:
+        raise UiPathNoMockFoundError()
     else:
         return await mocker.response(func, params, *args, **kwargs)
-
-
-_event_loop = None
-logger = logging.getLogger(__name__)
-
-
-def run_coroutine(coro):
-    """Run a coroutine synchronously."""
-    global _event_loop
-    if not _event_loop or not _event_loop.is_running():
-        _event_loop = asyncio.new_event_loop()
-        threading.Thread(target=_event_loop.run_forever, daemon=True).start()
-    future = asyncio.run_coroutine_threadsafe(coro, _event_loop)
-    return future.result()
-
-
-def mocked_response_decorator(func, params: dict[str, Any]):
-    """Mocked response decorator."""
-
-    async def mock_response_generator(*args, **kwargs):
-        mocked_response = await get_mocked_response(func, params, *args, **kwargs)
-        return_type: Any = func.__annotations__.get("return", None)
-
-        if return_type is not None:
-            mocked_response = TypeAdapter(return_type).validate_python(mocked_response)
-        return mocked_response
-
-    is_async = inspect.iscoroutinefunction(func)
-    if is_async:
-
-        @functools.wraps(func)
-        async def decorated_func(*args, **kwargs):
-            try:
-                return await mock_response_generator(*args, **kwargs)
-            except Exception:
-                logger.warning(
-                    f"Failed to mock response for {func.__name__}. Falling back to func."
-                )
-                return await func(*args, **kwargs)
-    else:
-
-        @functools.wraps(func)
-        def decorated_func(*args, **kwargs):
-            try:
-                return run_coroutine(mock_response_generator(*args, **kwargs))
-            except Exception:
-                logger.warning(
-                    f"Failed to mock response for {func.__name__}. Falling back to func."
-                )
-                return func(*args, **kwargs)
-
-    return decorated_func
-
-
-def mockable(
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    **kwargs,
-):
-    """Decorate a function to be a mockable."""
-
-    def decorator(func):
-        params = {
-            "name": name or func.__name__,
-            "description": description or func.__doc__,
-            "input_schema": get_input_schema(func),
-            "output_schema": get_output_schema(func),
-            **kwargs,
-        }
-        return mocked_response_decorator(func, params)
-
-    return decorator
-
-
-def get_output_schema(func):
-    """Retrieves the JSON schema for a function's return type hint."""
-    try:
-        adapter = TypeAdapter(inspect.signature(func).return_annotation)
-        return adapter.json_schema()
-    except Exception:
-        logger.warning(f"Unable to extract output schema for function {func.__name__}")
-        return {}
-
-
-def get_input_schema(func):
-    """Retrieves the JSON schema for a function's input type."""
-    try:
-        return ValidatedFunction(func).model.model_json_schema()
-    except Exception:
-        logger.warning(f"Unable to extract input schema for function {func.__name__}")
-        return {}

uipath/_services/llm_gateway_service.py

@@ -351,7 +351,8 @@ class UiPathLlmChatService(BaseService):
         n: int = 1,
         frequency_penalty: float = 0,
         presence_penalty: float = 0,
-        top_p: float = 1,
+        top_p: Optional[float] = 1,
+        top_k: Optional[int] = None,
         tools: Optional[List[ToolDefinition]] = None,
         tool_choice: Optional[ToolChoice] = None,
         response_format: Optional[Union[Dict[str, Any], type[BaseModel]]] = None,
@@ -385,6 +386,8 @@ class UiPathLlmChatService(BaseService):
                 Positive values encourage discussion of new topics. Defaults to 0.
             top_p (float, optional): Nucleus sampling parameter between 0 and 1.
                 Controls diversity by considering only the top p probability mass. Defaults to 1.
+            top_k (int, optional): Nucleus sampling parameter.
+                Controls diversity by considering only the top k most probable tokens. Defaults to None.
             tools (Optional[List[ToolDefinition]], optional): List of tool definitions that the
                 model can call. Tools enable the model to perform actions or retrieve information
                 beyond text generation. Defaults to None.
@@ -486,6 +489,8 @@ class UiPathLlmChatService(BaseService):
             "presence_penalty": presence_penalty,
             "top_p": top_p,
         }
+        if top_k is not None:
+            request_body["top_k"] = top_k
 
         # Handle response_format - convert BaseModel to schema if needed
         if response_format:

uipath/agent/models/agent.py

@@ -7,6 +7,7 @@ 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._cli._evals._models._mocks import ExampleCall
 from uipath.models import Connection
 
 
@@ -70,7 +71,13 @@ class AgentToolSettings(BaseModel):
     )
 
 
-class AgentProcessToolProperties(BaseModel):
+class BaseResourceProperties(BaseModel):
+    """Base resource properties."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentProcessToolProperties(BaseResourceProperties):
     """Properties specific to tool configuration."""
 
     folder_path: Optional[str] = Field(None, alias="folderPath")
@@ -125,7 +132,7 @@ class AgentIntegrationToolParameter(BaseModel):
     )
 
 
-class AgentIntegrationToolProperties(BaseModel):
+class AgentIntegrationToolProperties(BaseResourceProperties):
     """Properties specific to tool configuration."""
 
     tool_path: str = Field(..., alias="toolPath")
@@ -198,7 +205,7 @@ class AgentEscalationRecipient(BaseModel):
     )
 
 
-class AgentEscalationChannelProperties(BaseModel):
+class AgentEscalationChannelProperties(BaseResourceProperties):
     """Agent escalation channel properties."""
 
     app_name: str = Field(..., alias="appName")

uipath/eval/evaluators/trajectory_evaluator.py

@@ -6,12 +6,16 @@ from typing import Any, Optional
 from opentelemetry.sdk.trace import ReadableSpan
 from pydantic import field_validator
 
-from uipath._cli._evals._models._trajectory_span import TrajectoryEvaluationTrace
 from uipath.eval.models import EvaluationResult
 
 from ..._services import UiPathLlmChatService
 from ..._utils.constants import COMMUNITY_agents_SUFFIX
-from ..models.models import AgentExecution, LLMResponse, NumericEvaluationResult
+from ..models.models import (
+    AgentExecution,
+    LLMResponse,
+    NumericEvaluationResult,
+    TrajectoryEvaluationTrace,
+)
 from .base_evaluator import BaseEvaluator
 
 

uipath/eval/mocks/__init__.py

@@ -0,0 +1,7 @@
+"""Mock interface."""
+
+from uipath._cli._evals._models._mocks import ExampleCall
+
+from .mockable import mockable
+
+__all__ = ["ExampleCall", "mockable"]

uipath/eval/mocks/mockable.py

@@ -0,0 +1,101 @@
+"""Mockable interface."""
+
+import asyncio
+import functools
+import inspect
+import logging
+import threading
+from typing import Any, List, Optional
+
+from pydantic import TypeAdapter
+from pydantic_function_models import ValidatedFunction  # type: ignore[import-untyped]
+
+from uipath._cli._evals._models._mocks import ExampleCall
+from uipath._cli._evals.mocks.mocker import UiPathNoMockFoundError
+from uipath._cli._evals.mocks.mocks import get_mocked_response
+
+_event_loop = None
+logger = logging.getLogger(__name__)
+
+
+def run_coroutine(coro):
+    """Run a coroutine synchronously."""
+    global _event_loop
+    if not _event_loop or not _event_loop.is_running():
+        _event_loop = asyncio.new_event_loop()
+        threading.Thread(target=_event_loop.run_forever, daemon=True).start()
+    future = asyncio.run_coroutine_threadsafe(coro, _event_loop)
+    return future.result()
+
+
+def mocked_response_decorator(func, params: dict[str, Any]):
+    """Mocked response decorator."""
+
+    async def mock_response_generator(*args, **kwargs):
+        mocked_response = await get_mocked_response(func, params, *args, **kwargs)
+        return_type: Any = func.__annotations__.get("return", None)
+
+        if return_type is not None:
+            mocked_response = TypeAdapter(return_type).validate_python(mocked_response)
+        return mocked_response
+
+    is_async = inspect.iscoroutinefunction(func)
+    if is_async:
+
+        @functools.wraps(func)
+        async def decorated_func(*args, **kwargs):
+            try:
+                return await mock_response_generator(*args, **kwargs)
+            except UiPathNoMockFoundError:
+                return await func(*args, **kwargs)
+    else:
+
+        @functools.wraps(func)
+        def decorated_func(*args, **kwargs):
+            try:
+                return run_coroutine(mock_response_generator(*args, **kwargs))
+            except UiPathNoMockFoundError:
+                return func(*args, **kwargs)
+
+    return decorated_func
+
+
+def get_output_schema(func):
+    """Retrieves the JSON schema for a function's return type hint."""
+    try:
+        adapter = TypeAdapter(inspect.signature(func).return_annotation)
+        return adapter.json_schema()
+    except Exception:
+        logger.warning(f"Unable to extract output schema for function {func.__name__}")
+        return {}
+
+
+def get_input_schema(func):
+    """Retrieves the JSON schema for a function's input type."""
+    try:
+        return ValidatedFunction(func).model.model_json_schema()
+    except Exception:
+        logger.warning(f"Unable to extract input schema for function {func.__name__}")
+        return {}
+
+
+def mockable(
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    example_calls: Optional[List[ExampleCall]] = None,
+    **kwargs,
+):
+    """Decorate a function to be a mockable."""
+
+    def decorator(func):
+        params = {
+            "name": name or func.__name__,
+            "description": description or func.__doc__,
+            "input_schema": get_input_schema(func),
+            "output_schema": get_output_schema(func),
+            "example_calls": example_calls,
+            **kwargs,
+        }
+        return mocked_response_decorator(func, params)
+
+    return decorator

uipath/eval/models/models.py

@@ -1,7 +1,8 @@
 """Models for evaluation framework including execution data and evaluation results."""
 
+from dataclasses import dataclass
 from enum import IntEnum
-from typing import Annotated, Any, Dict, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 from opentelemetry.sdk.trace import ReadableSpan
 from pydantic import BaseModel, ConfigDict, Field
@@ -113,3 +114,111 @@ class EvaluatorType(IntEnum):
             return cls(value)
         else:
             raise ValueError(f"{value} is not a valid EvaluatorType value")
+
+
+@dataclass
+class TrajectoryEvaluationSpan:
+    """Simplified span representation for trajectory evaluation.
+
+    Contains span information needed for evaluating agent execution paths,
+    excluding timestamps which are not useful for trajectory analysis.
+    """
+
+    name: str
+    status: str
+    attributes: Dict[str, Any]
+    parent_name: Optional[str] = None
+    events: Optional[List[Dict[str, Any]]] = None
+
+    def __post_init__(self):
+        """Initialize default values."""
+        if self.events is None:
+            self.events = []
+
+    @classmethod
+    def from_readable_span(
+        cls, span: ReadableSpan, parent_spans: Optional[Dict[int, str]] = None
+    ) -> "TrajectoryEvaluationSpan":
+        """Convert a ReadableSpan to a TrajectoryEvaluationSpan.
+
+        Args:
+            span: The OpenTelemetry ReadableSpan to convert
+            parent_spans: Optional mapping of span IDs to names for parent lookup
+
+        Returns:
+            TrajectoryEvaluationSpan with relevant data extracted
+        """
+        # Extract status
+        status_map = {0: "unset", 1: "ok", 2: "error"}
+        status = status_map.get(span.status.status_code.value, "unknown")
+
+        # Extract attributes - keep all attributes for now
+        attributes = {}
+        if span.attributes:
+            attributes = dict(span.attributes)
+
+        # Get parent name if available
+        parent_name = None
+        if span.parent and parent_spans and span.parent.span_id in parent_spans:
+            parent_name = parent_spans[span.parent.span_id]
+
+        # Extract events (without timestamps)
+        events = []
+        if hasattr(span, "events") and span.events:
+            for event in span.events:
+                event_data = {
+                    "name": event.name,
+                    "attributes": dict(event.attributes) if event.attributes else {},
+                }
+                events.append(event_data)
+
+        return cls(
+            name=span.name,
+            status=status,
+            attributes=attributes,
+            parent_name=parent_name,
+            events=events,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "name": self.name,
+            "status": self.status,
+            "parent_name": self.parent_name,
+            "attributes": self.attributes,
+            "events": self.events,
+        }
+
+
+class TrajectoryEvaluationTrace(BaseModel):
+    """Container for a collection of trajectory evaluation spans."""
+
+    spans: List[TrajectoryEvaluationSpan]
+
+    @classmethod
+    def from_readable_spans(
+        cls, spans: List[ReadableSpan]
+    ) -> "TrajectoryEvaluationTrace":
+        """Convert a list of ReadableSpans to TrajectoryEvaluationTrace.
+
+        Args:
+            spans: List of OpenTelemetry ReadableSpans to convert
+
+        Returns:
+            TrajectoryEvaluationTrace with converted spans
+        """
+        # Create a mapping of span IDs to names for parent lookup
+        span_id_to_name = {span.get_span_context().span_id: span.name for span in spans}
+
+        evaluation_spans = [
+            TrajectoryEvaluationSpan.from_readable_span(span, span_id_to_name)
+            for span in spans
+        ]
+
+        return cls(spans=evaluation_spans)
+
+    class Config:
+        """Pydantic configuration."""
+
+        arbitrary_types_allowed = True

{uipath-2.1.76.dist-info → uipath-2.1.78.dist-info}/METADATA

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

@@ -48,19 +48,19 @@ uipath/_cli/_evals/_console_progress_reporter.py,sha256=HgB6pdMyoS6YVwuI3EpM2LBc
 uipath/_cli/_evals/_evaluator_factory.py,sha256=Gycv94VtGOpMir_Gba-UoiAyrSRfbSfe8_pTfjzcA9Q,3875
 uipath/_cli/_evals/_progress_reporter.py,sha256=kX7rNSa-QCLXIzK-vb9Jjf-XLEtucdeiQPgPlSkpp2U,16778
 uipath/_cli/_evals/_runtime.py,sha256=dz3mpZCLxwnLEdkwLo6W7qzBuVAklx6LMWtd4OMRk9w,15489
-uipath/_cli/_evals/_models/_evaluation_set.py,sha256=XgPNLWciE4FgCYzZXV2kRYHzdtbc33FWSQmZQqVSdMk,4747
+uipath/_cli/_evals/_models/_evaluation_set.py,sha256=TEinpTAIzy5JLkF7-JrG_623ec2Y-GN9pfz284KKL_8,4567
 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/_exceptions.py,sha256=-oXLTDa4ab9Boa34ZxuUrCezf8ajIGrIEUVwZnmBASE,195
+uipath/_cli/_evals/_models/_mocks.py,sha256=mlD9qvdZNniuKxzY_ttJtwLVFvKGvvIukYvy0FTa12k,241
 uipath/_cli/_evals/_models/_output.py,sha256=DmwFXh1YdLiMXyXmyoZr_4hgrrv3oiHbrrtIWMqGfsg,3145
 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/_evals/mocks/__init__.py,sha256=2WXwAy_oZw5bKp6L0HB13QygCJeftOB_Bget0AI6Gik,32
-uipath/_cli/_evals/mocks/llm_mocker.py,sha256=EtfPUhKcBRQ7vQPQdF3QanKIx2vzzYWA9PfdjKeJnTw,6108
-uipath/_cli/_evals/mocks/mocker.py,sha256=FjSIqXF5HzQRi1eWrFfXBz-cYZEu5TiMVm2RsKnSEWI,626
+uipath/_cli/_evals/mocks/llm_mocker.py,sha256=2pNCYKdXLoN_TTwiVk15RI-QC_CmHLaH40mFU1o4Ark,6828
+uipath/_cli/_evals/mocks/mocker.py,sha256=p9UpJDIckvCgkO0qqJHWdMMSbySBOoa8xpEIi2QIbhA,810
 uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf2UC5mXqwuUGTs,811
-uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=LtYT6lJM9vc3qtbSZJcUeCzDn4zarkBVj7In_EX7kYY,2087
-uipath/_cli/_evals/mocks/mocks.py,sha256=WqjWtHqKQXAsO1Wwom3Zcr1T09GQygwBWVp-EsxdW8o,4443
+uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=AO2BmFwA6hz3Lte-STVr7aJDPvMCqKNKa4j2jeNZ_U4,2677
+uipath/_cli/_evals/mocks/mocks.py,sha256=wPoZV-x-okPSVLJkHyBlAZZnClb5lr32ox_qsjo3y6E,1314
 uipath/_cli/_push/sw_file_handler.py,sha256=iE8Sk1Z-9hxmLFFj3j-k4kTK6TzNFP6hUCmxTudG6JQ,18251
 uipath/_cli/_runtime/_contracts.py,sha256=E8Is7EQfAu7_hCbeZI68gmTxSxo4X7_U4vcSl7D3Syg,28988
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
@@ -103,7 +103,7 @@ uipath/_services/documents_service.py,sha256=UnFS8EpOZ_Ng2TZk3OiJJ3iNANvFs7QxuoG
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
 uipath/_services/jobs_service.py,sha256=tTZNsdZKN3uP7bWPQyBCpJeQxTfuOWbKYOR4L-_yJo4,32736
-uipath/_services/llm_gateway_service.py,sha256=IBpkG2N2_9LGHkbajBoet9F26DqILC8zL4uHnnniQvg,24124
+uipath/_services/llm_gateway_service.py,sha256=oFBKSYbZqujGHDuM3A72S3J7mHn9kWjNTgcE3U0c24Y,24411
 uipath/_services/processes_service.py,sha256=O_uHgQ1rnwiV5quG0OQqabAnE6Rf6cWrMENYY2jKWt8,8585
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
 uipath/_utils/__init__.py,sha256=VdcpnENJIa0R6Y26NoxY64-wUVyvb4pKfTh1wXDQeMk,526
@@ -128,7 +128,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=a4tE5LTne0ghpb9qeKkvBAotFJSC88hQP-y7OKGrYXk,12976
+uipath/agent/models/agent.py,sha256=18NvqLtuQoEHYnrHiEApWjaka91PYCj_fJRFE72z4Uw,13236
 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
@@ -137,9 +137,11 @@ uipath/eval/evaluators/deterministic_evaluator_base.py,sha256=yDWTMU1mG-93D6DscA
 uipath/eval/evaluators/exact_match_evaluator.py,sha256=Qfz-kIUf80PKjAuge1Tc1GvN6kDB6hHveBZ86w_2How,1512
 uipath/eval/evaluators/json_similarity_evaluator.py,sha256=cP4kpN-UIf690V5dq4LaCjJc2zFx-nEffUclCwDdlhM,6607
 uipath/eval/evaluators/llm_as_judge_evaluator.py,sha256=l0bbn8ZLi9ZTXcgr7tJ2tsCvHFqIIeGa7sobaAHgI2Y,4927
-uipath/eval/evaluators/trajectory_evaluator.py,sha256=IylFm4yeNcVYgtmBzvzFn4Y2GXdSNnvAF8F4bCvPYdw,5774
+uipath/eval/evaluators/trajectory_evaluator.py,sha256=w9E8yUXp3KCXTfiUD-ut1OVyiOH3RpFFIIe7w3v3pBQ,5740
+uipath/eval/mocks/__init__.py,sha256=Qis6XSN7_WOmrmD_I5Fo5E_OQpflb_SlZM_MDOszUXI,152
+uipath/eval/mocks/mockable.py,sha256=LWrW9KgwE_HR8e3ql6xi1yq1naHhz-zv6Vw19NCx080,3224
 uipath/eval/models/__init__.py,sha256=x360CDZaRjUL3q3kh2CcXYYrQ47jwn6p6JnmhEIvMlA,419
-uipath/eval/models/models.py,sha256=is2wo-i0ld8Y_oZpbw5nG4cTXBz4bDLNxN6IjrfRcyM,2886
+uipath/eval/models/models.py,sha256=YgPnkQunjEcEiueVQnYRsbQ3Nj1yQttDQZiMCq_DDkY,6321
 uipath/models/__init__.py,sha256=d_DkK1AtRUetM1t2NrH5UKgvJOBiynzaKnK5pMY7aIc,1289
 uipath/models/action_schema.py,sha256=tBn1qQ3NQLU5nwWlBIzIKIx3XK5pO_D1S51IjFlZ1FA,610
 uipath/models/actions.py,sha256=1vRsJ3JSmMdPkbiYAiHzY8K44vmW3VlMsmQUBAkSgrQ,3141
@@ -167,8 +169,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.76.dist-info/METADATA,sha256=zT48rJq2Cbsdva0uAbrjk7eNsLGxBiq2YTjp327fJg8,6593
-uipath-2.1.76.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.76.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.76.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.76.dist-info/RECORD,,
+uipath-2.1.78.dist-info/METADATA,sha256=nkOYdZqbtr1-dVNdXhEMnuvgqC1D-ktHX2-n1u-nf3s,6593
+uipath-2.1.78.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.78.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.78.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.78.dist-info/RECORD,,

uipath/_cli/_evals/_models/_trajectory_span.py

@@ -1,115 +0,0 @@
-"""Trajectory evaluation span model for serializing span data in evaluations."""
-
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
-
-from opentelemetry.sdk.trace import ReadableSpan
-from pydantic import BaseModel
-
-
-@dataclass
-class TrajectoryEvaluationSpan:
-    """Simplified span representation for trajectory evaluation.
-
-    Contains span information needed for evaluating agent execution paths,
-    excluding timestamps which are not useful for trajectory analysis.
-    """
-
-    name: str
-    status: str
-    attributes: Dict[str, Any]
-    parent_name: Optional[str] = None
-    events: Optional[List[Dict[str, Any]]] = None
-
-    def __post_init__(self):
-        """Initialize default values."""
-        if self.events is None:
-            self.events = []
-
-    @classmethod
-    def from_readable_span(
-        cls, span: ReadableSpan, parent_spans: Optional[Dict[int, str]] = None
-    ) -> "TrajectoryEvaluationSpan":
-        """Convert a ReadableSpan to a TrajectoryEvaluationSpan.
-
-        Args:
-            span: The OpenTelemetry ReadableSpan to convert
-            parent_spans: Optional mapping of span IDs to names for parent lookup
-
-        Returns:
-            TrajectoryEvaluationSpan with relevant data extracted
-        """
-        # Extract status
-        status_map = {0: "unset", 1: "ok", 2: "error"}
-        status = status_map.get(span.status.status_code.value, "unknown")
-
-        # Extract attributes - keep all attributes for now
-        attributes = {}
-        if span.attributes:
-            attributes = dict(span.attributes)
-
-        # Get parent name if available
-        parent_name = None
-        if span.parent and parent_spans and span.parent.span_id in parent_spans:
-            parent_name = parent_spans[span.parent.span_id]
-
-        # Extract events (without timestamps)
-        events = []
-        if hasattr(span, "events") and span.events:
-            for event in span.events:
-                event_data = {
-                    "name": event.name,
-                    "attributes": dict(event.attributes) if event.attributes else {},
-                }
-                events.append(event_data)
-
-        return cls(
-            name=span.name,
-            status=status,
-            attributes=attributes,
-            parent_name=parent_name,
-            events=events,
-        )
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            "name": self.name,
-            "status": self.status,
-            "parent_name": self.parent_name,
-            "attributes": self.attributes,
-            "events": self.events,
-        }
-
-
-class TrajectoryEvaluationTrace(BaseModel):
-    """Container for a collection of trajectory evaluation spans."""
-
-    spans: List[TrajectoryEvaluationSpan]
-
-    @classmethod
-    def from_readable_spans(
-        cls, spans: List[ReadableSpan]
-    ) -> "TrajectoryEvaluationTrace":
-        """Convert a list of ReadableSpans to TrajectoryEvaluationTrace.
-
-        Args:
-            spans: List of OpenTelemetry ReadableSpans to convert
-
-        Returns:
-            TrajectoryEvaluationTrace with converted spans
-        """
-        # Create a mapping of span IDs to names for parent lookup
-        span_id_to_name = {span.get_span_context().span_id: span.name for span in spans}
-
-        evaluation_spans = [
-            TrajectoryEvaluationSpan.from_readable_span(span, span_id_to_name)
-            for span in spans
-        ]
-
-        return cls(spans=evaluation_spans)
-
-    class Config:
-        """Pydantic configuration."""
-
-        arbitrary_types_allowed = True