deepeval 3.8.1__py3-none-any.whl → 3.8.2__py3-none-any.whl

deepeval/_version.py

@@ -1 +1 @@
-__version__: str = "3.8.1"
+__version__: str = "3.8.2"

deepeval/confident/api.py

@@ -26,16 +26,44 @@ API_BASE_URL_EU = "https://eu.api.confident-ai.com"
 retryable_exceptions = requests.exceptions.SSLError
 
 
+def _infer_region_from_api_key(api_key: Optional[str]) -> Optional[str]:
+    """
+    Infer region from Confident API key prefix.
+
+    Supported:
+      - confident_eu_... => "EU"
+      - confident_us_... => "US"
+
+    Returns None if prefix is not recognized or api_key is falsy.
+    """
+    if not api_key:
+        return None
+    key = api_key.strip().lower()
+    if key.startswith("confident_eu_"):
+        return "EU"
+    if key.startswith("confident_us_"):
+        return "US"
+    return None
+
+
 def get_base_api_url():
     s = get_settings()
     if s.CONFIDENT_BASE_URL:
         base_url = s.CONFIDENT_BASE_URL.rstrip("/")
         return base_url
+    # If the user has explicitly set a region, respect it.
     region = KEY_FILE_HANDLER.fetch_data(KeyValues.CONFIDENT_REGION)
-    if region == "EU":
+    if region:
+        return API_BASE_URL_EU if region == "EU" else API_BASE_URL
+
+    # Otherwise, infer region from the API key prefix.
+    api_key = get_confident_api_key()
+    inferred = _infer_region_from_api_key(api_key)
+    if inferred == "EU":
         return API_BASE_URL_EU
-    else:
-        return API_BASE_URL
+
+    # Default to US (backwards compatible)
+    return API_BASE_URL
 
 
 def get_confident_api_key() -> Optional[str]:

deepeval/integrations/langchain/callback.py

@@ -1,3 +1,7 @@
+import logging
+import os
+import threading
+
 from typing import Any, Optional, List, Dict
 from uuid import UUID
 from time import perf_counter
@@ -20,6 +24,19 @@ from deepeval.tracing.types import (
 )
 from deepeval.telemetry import capture_tracing_integration
 
+# Debug logging for LangChain callbacks (enable with DEEPEVAL_DEBUG_LANGCHAIN_CALLBACKS=1)
+_DEBUG_CALLBACKS = os.environ.get(
+    "DEEPEVAL_DEBUG_LANGCHAIN_CALLBACKS", ""
+).lower() in ("1", "true", "yes")
+
+_logger = logging.getLogger(__name__)
+
+
+def _debug_log(msg: str):
+    if _DEBUG_CALLBACKS:
+        _logger.debug(f"[LangChain Callback] {msg}")
+
+
 try:
     from langchain_core.callbacks.base import BaseCallbackHandler
     from langchain_core.outputs import LLMResult
@@ -29,6 +46,7 @@ try:
     # contains langchain imports
     from deepeval.integrations.langchain.utils import (
         parse_prompts_to_messages,
+        convert_chat_messages_to_input,
         extract_name,
         safe_extract_model_name,
         safe_extract_token_usage,
@@ -50,6 +68,12 @@ def is_langchain_installed():
 
 
 class CallbackHandler(BaseCallbackHandler):
+    # When users create multiple CallbackHandler instances for the same logical
+    # conversation (same thread_id), we want spans to land on the same trace.
+    # Otherwise, each handler lazily creates its own trace, and multi-turn flows
+    # become multiple single-turn traces.
+    _thread_id_to_trace_uuid: Dict[str, str] = {}
+    _thread_id_lock = threading.Lock()
 
     def __init__(
         self,
@@ -74,13 +98,20 @@ class CallbackHandler(BaseCallbackHandler):
             self._parent_span = None
 
             # Stash trace metadata to apply once we know which trace we are using.
-            self._trace_init_fields: Dict[str, Any] = {
+            # _trace_init_fields is cleared after first apply to prevent re-applying
+            # on every callback within the same trace. _original_init_fields is kept
+            # permanently so we can re-apply when a new trace is created (e.g., in
+            # multi-turn scenarios where the previous trace was ended).
+            self._original_init_fields: Dict[str, Any] = {
                 "name": name,
                 "tags": tags,
                 "metadata": metadata,
                 "thread_id": thread_id,
                 "user_id": user_id,
             }
+            self._trace_init_fields: Dict[str, Any] = dict(
+                self._original_init_fields
+            )
 
             # Map LangChain run_id -> our span uuid for parent span restoration
             self._run_id_to_span_uuid: Dict[str, str] = {}
@@ -96,6 +127,34 @@ class CallbackHandler(BaseCallbackHandler):
         This is done lazily during actual callback execution to avoid context
         corruption when the handler is constructed outside the async task/context.
         """
+        # If the user provided a thread_id, attempt to reuse an existing trace for it.
+        # This makes multi-turn tests that use multiple CallbackHandler instances behave
+        # as expected: one trace containing multiple turns/spans.
+        thread_id = None
+        fields = self._trace_init_fields or {}
+        if fields.get("thread_id"):
+            thread_id = fields["thread_id"]
+        # In case _trace_init_fields has already been cleared, fall back to trace metadata.
+        if thread_id is None and self._trace is not None:
+            thread_id = self._trace.thread_id
+
+        if thread_id:
+            with self._thread_id_lock:
+                existing_uuid = self._thread_id_to_trace_uuid.get(thread_id)
+            if existing_uuid:
+                existing_trace = trace_manager.get_trace_by_uuid(existing_uuid)
+                if (
+                    existing_trace
+                    and existing_trace.uuid in trace_manager.active_traces
+                ):
+                    current_trace_context.set(existing_trace)
+                    self._trace = existing_trace
+                    self.trace_uuid = existing_trace.uuid
+                    # Lazily capture the observe parent span if present.
+                    if self._parent_span is None:
+                        self._parent_span = current_span_context.get()
+                    return existing_trace
+
         # Prefer current context trace if it is active.
         ctx_trace = current_trace_context.get()
         if ctx_trace and ctx_trace.uuid in trace_manager.active_traces:
@@ -107,6 +166,10 @@ class CallbackHandler(BaseCallbackHandler):
                 current_trace_context.set(trace)
             else:
                 # Otherwise, create a fresh trace now (in the right context).
+                # Restore _trace_init_fields from the original init fields so that
+                # the new trace gets the same name/tags/metadata as intended.
+                if not self._trace_init_fields and self._original_init_fields:
+                    self._trace_init_fields = dict(self._original_init_fields)
                 trace = trace_manager.start_new_trace()
                 current_trace_context.set(trace)
                 self._trace = trace
@@ -114,8 +177,18 @@ class CallbackHandler(BaseCallbackHandler):
         # Keep a copy for quick access.
         self.trace_uuid = trace.uuid
 
+        # Register this trace as the canonical trace for this thread_id (if provided).
+        # This allows other CallbackHandler instances created for the same thread_id
+        # to reuse the same trace instead of creating parallel traces.
+        fields = self._trace_init_fields or {}
+        tid = fields.get("thread_id") or trace.thread_id
+        if tid:
+            with self._thread_id_lock:
+                # Only set if absent to preserve the "first trace wins" behavior.
+                self._thread_id_to_trace_uuid.setdefault(tid, trace.uuid)
+
         # Apply stashed metadata once.
-        fields = getattr(self, "_trace_init_fields", None) or {}
+        fields = self._trace_init_fields or {}
         if fields:
             if fields.get("name") is not None:
                 trace.name = fields["name"]
@@ -202,6 +275,9 @@ class CallbackHandler(BaseCallbackHandler):
         metadata: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
+        _debug_log(
+            f"on_chain_start: run_id={run_id}, parent_run_id={parent_run_id}, name={extract_name(serialized, **kwargs)}"
+        )
         # Create spans for all chains to establish proper parent-child hierarchy
         # This is important for LangGraph where there are nested chains
         with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
@@ -232,6 +308,9 @@ class CallbackHandler(BaseCallbackHandler):
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,
     ) -> Any:
+        _debug_log(
+            f"on_chain_end: run_id={run_id}, parent_run_id={parent_run_id}"
+        )
         uuid_str = str(run_id)
         base_span = trace_manager.get_span_by_uuid(uuid_str)
         if base_span:
@@ -246,6 +325,59 @@ class CallbackHandler(BaseCallbackHandler):
                         trace.output = output
                 exit_current_context(uuid_str=uuid_str)
 
+    def on_chat_model_start(
+        self,
+        serialized: dict[str, Any],
+        messages: list[list[Any]],  # list[list[BaseMessage]]
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """
+        Handle chat model start callback. In LangChain v1, chat models emit
+        on_chat_model_start instead of on_llm_start. The on_llm_end callback
+        is still used for both.
+        """
+        _debug_log(
+            f"on_chat_model_start: run_id={run_id}, parent_run_id={parent_run_id}, messages_len={len(messages)}"
+        )
+
+        # Guard against double-counting if both on_llm_start and on_chat_model_start fire
+        uuid_str = str(run_id)
+        existing_span = trace_manager.get_span_by_uuid(uuid_str)
+        if existing_span is not None:
+            _debug_log(
+                f"on_chat_model_start: span already exists for run_id={run_id}, skipping"
+            )
+            return
+
+        with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
+            # Convert messages to our internal format using the shared helper
+            input_messages = convert_chat_messages_to_input(messages, **kwargs)
+
+            # Safe extraction of model name (handle None metadata)
+            md = metadata or {}
+            model = safe_extract_model_name(md, **kwargs)
+
+            llm_span: LlmSpan = enter_current_context(
+                uuid_str=uuid_str,
+                span_type="llm",
+                func_name=extract_name(serialized, **kwargs),
+            )
+            # Register this run_id -> span mapping for child callbacks
+            self._run_id_to_span_uuid[str(run_id)] = uuid_str
+
+            llm_span.input = input_messages
+            llm_span.model = model
+
+            # Extract metrics and prompt from metadata if provided, but don't mutate original
+            llm_span.metrics = md.get("metrics")
+            llm_span.metric_collection = md.get("metric_collection")
+            llm_span.prompt = md.get("prompt")
+
     def on_llm_start(
         self,
         serialized: dict[str, Any],
@@ -257,10 +389,25 @@ class CallbackHandler(BaseCallbackHandler):
         metadata: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
+        _debug_log(
+            f"on_llm_start: run_id={run_id}, parent_run_id={parent_run_id}, prompts_len={len(prompts)}"
+        )
+
+        # Guard against double-counting if both on_llm_start and on_chat_model_start fire
+        uuid_str = str(run_id)
+        existing_span = trace_manager.get_span_by_uuid(uuid_str)
+        if existing_span is not None:
+            _debug_log(
+                f"on_llm_start: span already exists for run_id={run_id}, skipping"
+            )
+            return
+
         with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
-            uuid_str = str(run_id)
             input_messages = parse_prompts_to_messages(prompts, **kwargs)
-            model = safe_extract_model_name(metadata, **kwargs)
+
+            # Safe extraction of model name (handle None metadata)
+            md = metadata or {}
+            model = safe_extract_model_name(md, **kwargs)
 
             llm_span: LlmSpan = enter_current_context(
                 uuid_str=uuid_str,
@@ -272,12 +419,11 @@ class CallbackHandler(BaseCallbackHandler):
 
             llm_span.input = input_messages
             llm_span.model = model
-            metrics = metadata.pop("metrics", None)
-            metric_collection = metadata.pop("metric_collection", None)
-            prompt = metadata.pop("prompt", None)
-            llm_span.metrics = metrics
-            llm_span.metric_collection = metric_collection
-            llm_span.prompt = prompt
+
+            # Extract metrics and prompt from metadata if provided, but don't mutate original
+            llm_span.metrics = md.get("metrics")
+            llm_span.metric_collection = md.get("metric_collection")
+            llm_span.prompt = md.get("prompt")
 
     def on_llm_end(
         self,
@@ -287,9 +433,20 @@ class CallbackHandler(BaseCallbackHandler):
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,  # un-logged kwargs
     ) -> Any:
+        _debug_log(
+            f"on_llm_end: run_id={run_id}, parent_run_id={parent_run_id}, response_type={type(response).__name__}"
+        )
         uuid_str = str(run_id)
         llm_span: LlmSpan = trace_manager.get_span_by_uuid(uuid_str)
         if llm_span is None:
+            _debug_log(f"on_llm_end: NO SPAN FOUND for run_id={run_id}")
+            return
+
+        # Guard against double-finalization (if both on_llm_end and on_chat_model_end fire)
+        if llm_span.end_time is not None:
+            _debug_log(
+                f"on_llm_end: span already finalized for run_id={run_id}, skipping"
+            )
             return
 
         with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
@@ -336,7 +493,6 @@ class CallbackHandler(BaseCallbackHandler):
                             )
 
             llm_span.model = model if model else llm_span.model
-            llm_span.input = llm_span.input
             llm_span.output = output
             llm_span.input_token_count = (
                 total_input_tokens if total_input_tokens > 0 else None
@@ -347,6 +503,121 @@ class CallbackHandler(BaseCallbackHandler):
 
             exit_current_context(uuid_str=uuid_str)
 
+    def on_chat_model_end(
+        self,
+        response: Any,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """
+        Handle chat model end callback. This may be called instead of or
+        in addition to on_llm_end depending on the LangChain version.
+        """
+        _debug_log(
+            f"on_chat_model_end: run_id={run_id}, parent_run_id={parent_run_id}, response_type={type(response).__name__}"
+        )
+        uuid_str = str(run_id)
+        llm_span: LlmSpan = trace_manager.get_span_by_uuid(uuid_str)
+        if llm_span is None:
+            _debug_log(f"on_chat_model_end: NO SPAN FOUND for run_id={run_id}")
+            return
+
+        # Guard against double-finalization, which could happen if both on_llm_end and on_chat_model_end fire
+        if llm_span.end_time is not None:
+            _debug_log(
+                f"on_chat_model_end: span already finalized for run_id={run_id}, skipping"
+            )
+            return
+
+        with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
+            output = ""
+            total_input_tokens = 0
+            total_output_tokens = 0
+            model = None
+
+            # Handle LLMResult (same as on_llm_end)
+            if isinstance(response, LLMResult):
+                for generation in response.generations:
+                    for gen in generation:
+                        if isinstance(gen, ChatGeneration):
+                            if gen.message.response_metadata and isinstance(
+                                gen.message.response_metadata, dict
+                            ):
+                                model = gen.message.response_metadata.get(
+                                    "model_name"
+                                )
+                                input_tokens, output_tokens = (
+                                    safe_extract_token_usage(
+                                        gen.message.response_metadata
+                                    )
+                                )
+                                total_input_tokens += input_tokens
+                                total_output_tokens += output_tokens
+
+                            if isinstance(gen.message, AIMessage):
+                                ai_message = gen.message
+                                tool_calls = []
+                                for tool_call in ai_message.tool_calls:
+                                    tool_calls.append(
+                                        LlmToolCall(
+                                            name=tool_call["name"],
+                                            args=tool_call["args"],
+                                            id=tool_call["id"],
+                                        )
+                                    )
+                                output = LlmOutput(
+                                    role="AI",
+                                    content=ai_message.content,
+                                    tool_calls=tool_calls,
+                                )
+
+            llm_span.model = model if model else llm_span.model
+            llm_span.output = output
+            llm_span.input_token_count = (
+                total_input_tokens if total_input_tokens > 0 else None
+            )
+            llm_span.output_token_count = (
+                total_output_tokens if total_output_tokens > 0 else None
+            )
+
+            exit_current_context(uuid_str=uuid_str)
+
+    def on_chat_model_error(
+        self,
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """
+        Handle chat model error callback.
+        """
+        _debug_log(
+            f"on_chat_model_error: run_id={run_id}, parent_run_id={parent_run_id}, error={error}"
+        )
+        uuid_str = str(run_id)
+        llm_span: LlmSpan = trace_manager.get_span_by_uuid(uuid_str)
+        if llm_span is None:
+            _debug_log(
+                f"on_chat_model_error: NO SPAN FOUND for run_id={run_id}"
+            )
+            return
+
+        # Guard against double-finalization
+        if llm_span.end_time is not None:
+            _debug_log(
+                f"on_chat_model_error: span already finalized for run_id={run_id}, skipping"
+            )
+            return
+
+        with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
+            llm_span.status = TraceSpanStatus.ERRORED
+            llm_span.error = str(error)
+            exit_current_context(uuid_str=uuid_str)
+
     def on_llm_error(
         self,
         error: BaseException,
@@ -355,10 +626,22 @@ class CallbackHandler(BaseCallbackHandler):
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,
     ) -> Any:
+        _debug_log(
+            f"on_llm_error: run_id={run_id}, parent_run_id={parent_run_id}, error={error}"
+        )
         uuid_str = str(run_id)
         llm_span: LlmSpan = trace_manager.get_span_by_uuid(uuid_str)
         if llm_span is None:
+            _debug_log(f"on_llm_error: NO SPAN FOUND for run_id={run_id}")
+            return
+
+        # Guard against double-finalization
+        if llm_span.end_time is not None:
+            _debug_log(
+                f"on_llm_error: span already finalized for run_id={run_id}, skipping"
+            )
             return
+
         with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
             llm_span.status = TraceSpanStatus.ERRORED
             llm_span.error = str(error)
@@ -396,6 +679,9 @@ class CallbackHandler(BaseCallbackHandler):
         inputs: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
+        _debug_log(
+            f"on_tool_start: run_id={run_id}, parent_run_id={parent_run_id}, name={extract_name(serialized, **kwargs)}"
+        )
         with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
             uuid_str = str(run_id)
 
@@ -418,6 +704,9 @@ class CallbackHandler(BaseCallbackHandler):
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,  # un-logged kwargs
     ) -> Any:
+        _debug_log(
+            f"on_tool_end: run_id={run_id}, parent_run_id={parent_run_id}"
+        )
         uuid_str = str(run_id)
         tool_span: ToolSpan = trace_manager.get_span_by_uuid(uuid_str)
         if tool_span is None:
@@ -485,20 +774,23 @@ class CallbackHandler(BaseCallbackHandler):
     ) -> Any:
         with self._ctx(run_id=run_id, parent_run_id=parent_run_id):
             uuid_str = str(run_id)
+            # Safe access to metadata (handle None)
+            md = metadata or {}
             retriever_span = enter_current_context(
                 uuid_str=uuid_str,
                 span_type="retriever",
                 func_name=extract_name(serialized, **kwargs),
                 observe_kwargs={
-                    "embedder": metadata.get(
-                        "ls_embedding_provider", "unknown"
-                    ),
+                    "embedder": md.get("ls_embedding_provider", "unknown"),
                 },
             )
             # Register this run_id -> span mapping for child callbacks
             self._run_id_to_span_uuid[str(run_id)] = uuid_str
             retriever_span.input = query
 
+            # Extract metric_collection from metadata if provided
+            retriever_span.metric_collection = md.get("metric_collection")
+
     def on_retriever_end(
         self,
         output: Any,

deepeval/integrations/langchain/utils.py

@@ -1,5 +1,77 @@
-from typing import Any, List, Dict, Optional
+import uuid
+from typing import Any, List, Dict, Optional, Union, Literal, Callable
+from time import perf_counter
 from langchain_core.outputs import ChatGeneration
+from rich.progress import Progress
+
+from deepeval.metrics import BaseMetric
+from deepeval.tracing.context import current_span_context, current_trace_context
+from deepeval.tracing.tracing import trace_manager
+from deepeval.tracing.types import (
+    AgentSpan,
+    BaseSpan,
+    LlmSpan,
+    RetrieverSpan,
+    SpanType,
+    ToolSpan,
+    TraceSpanStatus,
+)
+
+
+def convert_chat_messages_to_input(
+    messages: list[list[Any]], **kwargs
+) -> List[Dict[str, str]]:
+    """
+    Convert LangChain chat messages to our internal format.
+
+    Args:
+        messages: list[list[BaseMessage]] - outer list is batches, inner is messages.
+        **kwargs: May contain invocation_params with tools definitions.
+
+    Returns:
+        List of dicts with 'role' and 'content' keys, matching the schema used
+        by parse_prompts_to_messages for consistency.
+    """
+    # Valid roles matching parse_prompts_to_messages
+    ROLE_MAPPING = {
+        "human": "human",
+        "user": "human",
+        "ai": "ai",
+        "assistant": "ai",
+        "system": "system",
+        "tool": "tool",
+        "function": "function",
+    }
+
+    result: List[Dict[str, str]] = []
+    for batch in messages:
+        for msg in batch:
+            # BaseMessage has .type (role) and .content
+            raw_role = getattr(msg, "type", "unknown")
+            content = getattr(msg, "content", "")
+
+            # Normalize role using same conventions as prompt parsing
+            role = ROLE_MAPPING.get(raw_role.lower(), raw_role)
+
+            # Convert content to string (handles empty content, lists, etc.)
+            if isinstance(content, list):
+                # Some messages have content as a list of content blocks
+                content_str = " ".join(
+                    str(c.get("text", c) if isinstance(c, dict) else c)
+                    for c in content
+                )
+            else:
+                content_str = str(content) if content else ""
+
+            result.append({"role": role, "content": content_str})
+
+    # Append tool definitions if present which matches parse_prompts_to_messages behavior
+    tools = kwargs.get("invocation_params", {}).get("tools", None)
+    if tools and isinstance(tools, list):
+        for tool in tools:
+            result.append({"role": "Tool Input", "content": str(tool)})
+
+    return result
 
 
 def parse_prompts_to_messages(
@@ -112,27 +184,6 @@ def safe_extract_model_name(
     return None
 
 
-from typing import Any, List, Dict, Optional, Union, Literal, Callable
-from langchain_core.outputs import ChatGeneration
-from time import perf_counter
-import uuid
-from rich.progress import Progress
-from deepeval.tracing.tracing import Observer
-
-from deepeval.metrics import BaseMetric
-from deepeval.tracing.context import current_span_context, current_trace_context
-from deepeval.tracing.tracing import trace_manager
-from deepeval.tracing.types import (
-    AgentSpan,
-    BaseSpan,
-    LlmSpan,
-    RetrieverSpan,
-    SpanType,
-    ToolSpan,
-    TraceSpanStatus,
-)
-
-
 def enter_current_context(
     span_type: Optional[
         Union[Literal["agent", "llm", "retriever", "tool"], str]
@@ -239,8 +290,8 @@ def enter_current_context(
 
     if (
         parent_span
-        and getattr(parent_span, "progress", None) is not None
-        and getattr(parent_span, "pbar_callback_id", None) is not None
+        and parent_span.progress is not None
+        and parent_span.pbar_callback_id is not None
     ):
         progress = parent_span.progress
         pbar_callback_id = parent_span.pbar_callback_id

deepeval/integrations/pydantic_ai/instrumentator.py

@@ -40,6 +40,7 @@ try:
     from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
         OTLPSpanExporter,
     )
+    from opentelemetry.trace import set_tracer_provider
     from pydantic_ai.models.instrumented import (
         InstrumentationSettings as _BaseInstrumentationSettings,
     )
@@ -131,7 +132,12 @@ class ConfidentInstrumentationSettings(InstrumentationSettings):
     ):
         is_dependency_installed()
 
-        _environment = os.getenv("CONFIDENT_TRACE_ENVIRONMENT", "development")
+        if trace_manager.environment is not None:
+            _environment = trace_manager.environment
+        elif settings.CONFIDENT_TRACE_ENVIRONMENT is not None:
+            _environment = settings.CONFIDENT_TRACE_ENVIRONMENT
+        else:
+            _environment = "development"
         if _environment and _environment in [
             "production",
             "staging",
@@ -176,6 +182,12 @@ class ConfidentInstrumentationSettings(InstrumentationSettings):
                     )
                 )
             )
+        try:
+            set_tracer_provider(trace_provider)
+        except Exception as e:
+            # Handle case where provider is already set (optional warning)
+            logger.warning(f"Could not set global tracer provider: {e}")
+
         super().__init__(tracer_provider=trace_provider)
 
 
@@ -234,16 +246,14 @@ class SpanInterceptor(SpanProcessor):
             )
 
         # set agent name and metric collection
-        if span.attributes.get("agent_name"):
-            span.set_attribute("confident.span.type", "agent")
-            span.set_attribute(
-                "confident.span.name", span.attributes.get("agent_name")
-            )
-            if self.settings.agent_metric_collection:
-                span.set_attribute(
-                    "confident.span.metric_collection",
-                    self.settings.agent_metric_collection,
-                )
+        agent_name = (
+            span.attributes.get("gen_ai.agent.name")
+            or span.attributes.get("pydantic_ai.agent.name")
+            or span.attributes.get("agent_name")
+        )
+
+        if agent_name:
+            self._add_agent_span(span, agent_name)
 
         # set llm metric collection
         if span.attributes.get("gen_ai.operation.name") in [
@@ -270,6 +280,19 @@ class SpanInterceptor(SpanProcessor):
                 )
 
     def on_end(self, span):
+
+        already_processed = (
+            span.attributes.get("confident.span.type") == "agent"
+        )
+        if not already_processed:
+            agent_name = (
+                span.attributes.get("gen_ai.agent.name")
+                or span.attributes.get("pydantic_ai.agent.name")
+                or span.attributes.get("agent_name")
+            )
+            if agent_name:
+                self._add_agent_span(span, agent_name)
+
         if self.settings.is_test_mode:
             if span.attributes.get("confident.span.type") == "agent":
 
@@ -323,3 +346,12 @@ class SpanInterceptor(SpanProcessor):
                 trace.end_time = perf_counter()
                 trace_manager.traces_to_evaluate.append(trace)
                 test_exporter.clear_span_json_list()
+
+    def _add_agent_span(self, span, name):
+        span.set_attribute("confident.span.type", "agent")
+        span.set_attribute("confident.span.name", name)
+        if self.settings.agent_metric_collection:
+            span.set_attribute(
+                "confident.span.metric_collection",
+                self.settings.agent_metric_collection,
+            )

deepeval/integrations/pydantic_ai/otel.py

@@ -2,6 +2,7 @@ import warnings
 from typing import Optional
 from deepeval.telemetry import capture_tracing_integration
 from deepeval.config.settings import get_settings
+import logging
 
 try:
     from opentelemetry import trace
@@ -24,6 +25,9 @@ def is_opentelemetry_available():
     return True
 
 
+logger = logging.getLogger(__name__)
+settings = get_settings()
+
 settings = get_settings()
 # OTLP_ENDPOINT = "https://otel.confident-ai.com/v1/traces"
 
@@ -51,6 +55,11 @@ def instrument_pydantic_ai(api_key: Optional[str] = None):
                 )
             )
         )
+        try:
+            trace.set_tracer_provider(tracer_provider)
+        except Exception as e:
+            # Handle case where provider is already set (optional warning)
+            logger.warning(f"Could not set global tracer provider: {e}")
 
         # create an instrumented exporter
         from pydantic_ai.models.instrumented import InstrumentationSettings

deepeval/metrics/utils.py

@@ -320,6 +320,17 @@ def check_llm_test_case_params(
         metric.error = error_str
         raise ValueError(error_str)
 
+    # Centralized: if a metric requires actual_output, reject empty/whitespace
+    # (including empty multimodal outputs) as "missing params".
+    if LLMTestCaseParams.ACTUAL_OUTPUT in test_case_params:
+        actual_output = getattr(
+            test_case, LLMTestCaseParams.ACTUAL_OUTPUT.value
+        )
+        if isinstance(actual_output, str) and actual_output == "":
+            error_str = f"'actual_output' cannot be empty for the '{metric.__name__}' metric"
+            metric.error = error_str
+            raise MissingTestCaseParamsError(error_str)
+
     missing_params = []
     for param in test_case_params:
         if getattr(test_case, param.value) is None:

deepeval/simulator/conversation_simulator.py

@@ -610,7 +610,8 @@ class ConversationSimulator:
     ) -> BaseModel:
         if self.using_native_model:
             res, cost = self.simulator_model.generate(prompt, schema=schema)
-            self.simulation_cost += cost
+            if cost is not None:
+                self.simulation_cost += cost
             return res
         else:
             try:
@@ -630,7 +631,8 @@ class ConversationSimulator:
             res, cost = await self.simulator_model.a_generate(
                 prompt, schema=schema
             )
-            self.simulation_cost += cost
+            if cost is not None:
+                self.simulation_cost += cost
             return res
         else:
             try:

deepeval/telemetry.py

@@ -1,5 +1,4 @@
 from contextlib import contextmanager
-import logging
 import os
 import socket
 import sys
@@ -85,13 +84,6 @@ if not telemetry_opt_out():
 anonymous_public_ip = None
 
 if not telemetry_opt_out():
-    from opentelemetry import trace
-    from opentelemetry.sdk.trace import TracerProvider
-    from opentelemetry.sdk.trace.export import BatchSpanProcessor
-    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-        OTLPSpanExporter,
-    )
-
     anonymous_public_ip = get_anonymous_public_ip()
     sentry_sdk.init(
         dsn="https://5ef587d58109ee45d6544f3657efdd1f@o4506098477236224.ingest.sentry.io/4506098479136768",
@@ -102,27 +94,6 @@ if not telemetry_opt_out():
         default_integrations=False,  # Disable Sentry's default integrations
     )
 
-    # Set up the Tracer Provider
-    trace.set_tracer_provider(TracerProvider())
-    tracer_provider = trace.get_tracer_provider()
-
-    # New Relic License Key and OTLP Endpoint
-    NEW_RELIC_LICENSE_KEY = "1711c684db8a30361a7edb0d0398772cFFFFNRAL"
-    NEW_RELIC_OTLP_ENDPOINT = "https://otlp.nr-data.net:4317"
-    otlp_exporter = OTLPSpanExporter(
-        endpoint=NEW_RELIC_OTLP_ENDPOINT,
-        headers={"api-key": NEW_RELIC_LICENSE_KEY},
-    )
-
-    # Add the OTLP exporter to the span processor
-    span_processor = BatchSpanProcessor(otlp_exporter)
-    tracer_provider.add_span_processor(span_processor)
-
-    logging.getLogger("opentelemetry.exporter.otlp").setLevel(logging.CRITICAL)
-
-    # Create a tracer for your application
-    tracer = trace.get_tracer(__name__)
-
     # Initialize PostHog
     posthog = Posthog(
         project_api_key="phc_IXvGRcscJJoIb049PtjIZ65JnXQguOUZ5B5MncunFdB",
@@ -199,11 +170,7 @@ def capture_evaluation_run(type: str):
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -227,11 +194,7 @@ def capture_recommend_metrics():
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -259,11 +222,7 @@ def capture_metric_type(
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -297,11 +256,7 @@ def capture_synthesizer_run(
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -330,11 +285,7 @@ def capture_conversation_simulator_run(num_conversations: int):
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -360,11 +311,7 @@ def capture_guardrails(guards: List[str]):
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -391,11 +338,7 @@ def capture_benchmark_run(benchmark: str, num_tasks: int):
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -421,11 +364,7 @@ def capture_login_event():
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -451,11 +390,7 @@ def capture_view_event():
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 @contextmanager
@@ -478,11 +413,7 @@ def capture_pull_dataset():
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 # track metrics that are components and metrics that aren't components
@@ -509,11 +440,7 @@ def capture_send_trace():
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            yield span
+        yield
 
 
 # tracing integration
@@ -542,13 +469,7 @@ def capture_tracing_integration(integration_name: str):
         posthog.capture(
             distinct_id=distinct_id, event=event, properties=properties
         )
-        # capture new relic
-        with tracer.start_as_current_span(event) as span:
-            for property, value in properties.items():
-                span.set_attribute(property, value)
-            # OTEL/New Relic filtering attributes
-            span.set_attribute("integration.name", integration_name)
-            yield span
+        yield
 
 
 #########################################################

deepeval/tracing/tracing.py

@@ -969,9 +969,9 @@ class Observer:
         else:
             current_trace = current_trace_context.get()
             if current_trace.input is None:
-                current_trace.input = self.function_kwargs
+                current_trace.input = trace_manager.mask(self.function_kwargs)
             if current_trace.output is None:
-                current_trace.output = self.result
+                current_trace.output = trace_manager.mask(self.result)
             if current_span.status == TraceSpanStatus.ERRORED:
                 current_trace.status = TraceSpanStatus.ERRORED
             if current_trace and current_trace.uuid == current_span.trace_uuid:
@@ -1037,7 +1037,8 @@ class Observer:
             return RetrieverSpan(**span_kwargs, embedder=embedder)
 
         elif self.span_type == SpanType.TOOL.value:
-            return ToolSpan(**span_kwargs, **self.observe_kwargs)
+            description = self.observe_kwargs.get("description", None)
+            return ToolSpan(**span_kwargs, description=description)
         else:
             return BaseSpan(**span_kwargs)
 
@@ -1107,7 +1108,7 @@ def observe(
                             yield chunk
                         observer.__exit__(None, None, None)
                     except Exception as e:
-                        observer.__exit__(type(e), e, e.__traceback__)
+                        observer.__exit__(e.__class__, e, e.__traceback__)
                         raise
 
                 return gen()
@@ -1150,7 +1151,7 @@ def observe(
                         yield from original_gen
                         observer.__exit__(None, None, None)
                     except Exception as e:
-                        observer.__exit__(type(e), e, e.__traceback__)
+                        observer.__exit__(e.__class__, e, e.__traceback__)
                         raise
 
                 return gen()

{deepeval-3.8.1.dist-info → deepeval-3.8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepeval
-Version: 3.8.1
+Version: 3.8.2
 Summary: The LLM Evaluation Framework
 Home-page: https://github.com/confident-ai/deepeval
 License: Apache-2.0

{deepeval-3.8.1.dist-info → deepeval-3.8.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 deepeval/__init__.py,sha256=tle4lT4FONApg3OeztGPEdrpGMEGLWajyGTu7bEd3s0,2976
-deepeval/_version.py,sha256=s5IY-4O1-t7edS5QfrE_aVtx7pzfmiAZYhpUiCZuYuY,27
+deepeval/_version.py,sha256=A8HjzlffHmJot3rBAExqN_D-QxaG8UT8zqiP26xCL2M,27
 deepeval/annotation/__init__.py,sha256=ZFhUVNNuH_YgQSZJ-m5E9iUb9TkAkEV33a6ouMDZ8EI,111
 deepeval/annotation/annotation.py,sha256=WLFZRkx6wRJcNzaOMMGXuTfw6Q1_1Mv5A4jpD7Ea4sU,2300
 deepeval/annotation/api.py,sha256=EYN33ACVzVxsFleRYm60KB4Exvff3rPJKt1VBuuX970,2147
@@ -142,7 +142,7 @@ deepeval/cli/test.py,sha256=aoBPMfk0HTvOqb2xdvMykkx_s4SHst7lEnoUiSXo1lU,5483
 deepeval/cli/types.py,sha256=_7KdthstHNc-JKCWrfpDQCf_j8h9PMxh0qJCHmVXJr0,310
 deepeval/cli/utils.py,sha256=3fgH5WPTTe7Cz_QOLCHyflXB81kmFaSxXHJ2tnxvFLw,10649
 deepeval/confident/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-deepeval/confident/api.py,sha256=3TpuZm59xo1_APsAPppreCRepf8pfGWksMmgxnwp764,8773
+deepeval/confident/api.py,sha256=rxMNMK5VYPQKdEDSRsovlULV14QlGW3TNDkARLj_Pt4,9589
 deepeval/confident/types.py,sha256=9bgePDaU31yY7JGwCLZcc7pev9VGtNDZLbjsVpCLVdc,574
 deepeval/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepeval/config/dotenv_handler.py,sha256=lOosoC7fm9RljriY8EFl5ywSGfSiQsVf_vmYqzpbZ8s,588
@@ -180,16 +180,16 @@ deepeval/integrations/hugging_face/rich_manager.py,sha256=WvFtPGpPmGeg2Ftsnojga6
 deepeval/integrations/hugging_face/tests/test_callbacks.py,sha256=88Wyg-aDaXujj9jHeGdFF3ITSl2-y7eaJGWgSyvvDi8,4607
 deepeval/integrations/hugging_face/utils.py,sha256=HUKdQcTIb76Ct69AS737oPxmlVxk5fw2UbT2pLn-o8k,1817
 deepeval/integrations/langchain/__init__.py,sha256=G1Qey5WkKou2-PA34KwWgmayQ_TbvXqPyotTbzmD8tw,84
-deepeval/integrations/langchain/callback.py,sha256=HzeSDvSanjVRe7kquFdRUG9f88QmzU0y3prdUqF8O3g,20361
+deepeval/integrations/langchain/callback.py,sha256=uZrhmlzw2dcFunqQzNPfMo9vWkHCX7PbGbazKRhBbBY,32687
 deepeval/integrations/langchain/patch.py,sha256=fCHfZXU9xX3IJ6SG8GEYzn3qrifyUkT0i_uUABTsmcs,1255
-deepeval/integrations/langchain/utils.py,sha256=oYsQYO3Ucbmd1d7gkb5ARd60gm6BHtLy_5OOqUw8HIQ,11311
+deepeval/integrations/langchain/utils.py,sha256=mhv0anU5ZnbBsESMuCooT9FSNPkx2ObrVLlq7QNEZOI,13104
 deepeval/integrations/llama_index/__init__.py,sha256=Ujs9ZBJFkuCWUDBJOF88UbM1Y-S6QFQhxSo0oQnEWNw,90
 deepeval/integrations/llama_index/handler.py,sha256=uTvNXmAF4xBh8t9bBm5sBFX6ETp8SrkOZlFlE_GWdmM,10771
 deepeval/integrations/llama_index/utils.py,sha256=onmmo1vpn6cpOY5EhfTc0Uui7X6l1M0HD3sq-KVAesg,3380
 deepeval/integrations/pydantic_ai/__init__.py,sha256=UIkXn_g6h9LTQXG1PaWu1eCFkCssIwG48WSvN46UWgU,202
 deepeval/integrations/pydantic_ai/agent.py,sha256=-NKvpTUw3AxRNhuxVFcx9mw5BWCujzOwsaC8u7K0ubc,1178
-deepeval/integrations/pydantic_ai/instrumentator.py,sha256=Us9LSYZWMfaeAc7PGXMDYWzjWKFVmhRvZrFhSvmk448,11922
-deepeval/integrations/pydantic_ai/otel.py,sha256=CCqwCJ5pHqCzHgujHQqZy7Jxo2PH1BT0kR7QxdtzutY,2060
+deepeval/integrations/pydantic_ai/instrumentator.py,sha256=COqw4FJsUZacaP4Dfn1aaOXvUTvZOuhcqqQD-_sLD04,13047
+deepeval/integrations/pydantic_ai/otel.py,sha256=xWYnMT1HwcAmyWdoJa6C1sHwd5frP9_IcR8dj9sKsG0,2386
 deepeval/integrations/pydantic_ai/test_instrumentator.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepeval/key_handler.py,sha256=lajMBgF2lCzbQpW4e6Y7cD9FOw0Qk5UOKS4_kIIHj6Y,9562
 deepeval/metrics/__init__.py,sha256=19Df323r8aAlx2sRfV9BHJLicORhTLpogR8M1deJetw,4680
@@ -384,7 +384,7 @@ deepeval/metrics/turn_relevancy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 deepeval/metrics/turn_relevancy/schema.py,sha256=om0zFJcM6qu2GWS9aJTP3lUmuEXX8KpoACEvCsJqfq4,234
 deepeval/metrics/turn_relevancy/template.py,sha256=k02QVclRtCTVBZ7Xd4f-LdTrSO_dBxquQiFYqRYmiSA,3245
 deepeval/metrics/turn_relevancy/turn_relevancy.py,sha256=gMx5o5vfPJjVKior96L_A-4o3IoAyxSoTgI8U9sJtRY,9468
-deepeval/metrics/utils.py,sha256=kEWt0iKsBmABBtkHnk3vbHoOkYdU5hhAhBkx9-0k0Fc,21370
+deepeval/metrics/utils.py,sha256=osdTrK0jMiMynfks3uUFx6KmhcbRmr41ZXoGMisx2xY,21932
 deepeval/model_integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepeval/model_integrations/types.py,sha256=rbVMhC_2yWwD6JqzkRO9D7aMVC_KtXN686G_S7de7S8,630
 deepeval/model_integrations/utils.py,sha256=Zt9SYPgTxlGsQFZgpZvh_a5fWuL8mmIFVSe6uoQywZ4,3562
@@ -468,7 +468,7 @@ deepeval/red_teaming/README.md,sha256=BY5rAdpp3-sMMToEKwq0Nsd9ivkGDzPE16DeDb8GY7
 deepeval/scorer/__init__.py,sha256=hTvtoV3a4l0dSBjERm-jX7jveTtKZXK0c9JerQo0T_w,27
 deepeval/scorer/scorer.py,sha256=EmXo1wEMMAL2it8WxNJ4cTqZLCH1ad4BY2VewoX6b10,18348
 deepeval/simulator/__init__.py,sha256=wkyevg9nh46rsVnVrBjY3K5bHlkqjwx4TtrTfyjDCO0,96
-deepeval/simulator/conversation_simulator.py,sha256=I3YotQiAjPY8nvaC8pe_HDcwkzU78XTT88USj4D0Tr4,27208
+deepeval/simulator/conversation_simulator.py,sha256=RfCZZmxiKNiSmd_g9CN-Un_ekkqeyDARP3aXcj3rUck,27282
 deepeval/simulator/schema.py,sha256=16X2-m92plP52YTd-dvECt_-6gsz0U4j7Ut3UdI6gKY,252
 deepeval/simulator/template.py,sha256=6wh6xiUaZQn-pvkBWgOK7pWfsv5nntgjGfTqUkcKn0A,6461
 deepeval/singleton.py,sha256=irNbt0-IRI7rD4t05OZHsrNovpeva0XPc8PoieFytG8,532
@@ -486,7 +486,7 @@ deepeval/synthesizer/templates/template_extraction.py,sha256=jmvr8AOOUzDgsHYIOsq
 deepeval/synthesizer/templates/template_prompt.py,sha256=bzfC71AXZqBrmoDWmBvuIQKD6hPJZ0ZAWX4hy-lPlnQ,21478
 deepeval/synthesizer/types.py,sha256=wUZntvCAE29sM9K8hk9RPwUpkTip1ObOCExyMEo3sME,493
 deepeval/synthesizer/utils.py,sha256=o-9z5gApQcHqDqusgrD0LagXWAju17LVc27BxtaA7og,1018
-deepeval/telemetry.py,sha256=0k6oVhRBi1Ap6JC6SNe_9-nBnlG-uReUoS3KTrPayhk,21716
+deepeval/telemetry.py,sha256=VSPAv1XWS0jzDIjPzgAg42WDfYgqaR4Iwi8RrM_aPns,18041
 deepeval/test_case/__init__.py,sha256=i1hIGeE_J1Zm-KmDVFqmogvBKzyOlIsENrfhL-3B8_M,658
 deepeval/test_case/api.py,sha256=i9e1ggt4O9w_cu7tMSArw-LkiIZ_u_WPgpM2YAhfgks,3408
 deepeval/test_case/arena_test_case.py,sha256=ngEU5_-YVQ-qPSOVVuSUJ_nuvdQR-MGA_QZQst5c8MI,1482
@@ -516,12 +516,12 @@ deepeval/tracing/patchers.py,sha256=Oi9wao3oDYhcviv7p0KoWBeS9ne7rHLa2gh9AR9EyiU,
 deepeval/tracing/perf_epoch_bridge.py,sha256=iyAPddB6Op7NpMtPHJ29lDm53Btz9yLaN6xSCfTRQm4,1825
 deepeval/tracing/trace_context.py,sha256=Z0n0Cu1A5g9dXiZnzTFO5TzeOYHKeNuO6v3_EU_Gi_c,3568
 deepeval/tracing/trace_test_manager.py,sha256=wt4y7EWTRc4Bw938-UFFtXHkdFFOrnx6JaIk7J5Iulw,555
-deepeval/tracing/tracing.py,sha256=AkbmgjWzSQ2k2qeN9i8LT17MsafuBenzzkP0r31I950,46728
+deepeval/tracing/tracing.py,sha256=ge3XXJkxlmCk5KfrqOOjxXIuA1CIXFOKJxhRTmXRSVQ,46849
 deepeval/tracing/types.py,sha256=3QkF0toQ6f0fEDARYOUV6Iv9UJFbg14kSpn3dL1H5CE,6040
 deepeval/tracing/utils.py,sha256=mdvhYAxDNsdnusaEXJd-c-_O2Jn6S3xSuzRvLO1Jz4U,5684
 deepeval/utils.py,sha256=Wsu95g6t1wdttxWIESVwuUxbml7C-9ZTsV7qHCQI3Xg,27259
-deepeval-3.8.1.dist-info/LICENSE.md,sha256=0ATkuLv6QgsJTBODUHC5Rak_PArA6gv2t7inJzNTP38,11352
-deepeval-3.8.1.dist-info/METADATA,sha256=Gnf6RPJE1gh6N5HJlJAEEPZvRTGVE_g57hkAeAnPzvE,18752
-deepeval-3.8.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-deepeval-3.8.1.dist-info/entry_points.txt,sha256=NoismUQfwLOojSGZmBrdcpwfaoFRAzUhBvZD3UwOKog,95
-deepeval-3.8.1.dist-info/RECORD,,
+deepeval-3.8.2.dist-info/LICENSE.md,sha256=0ATkuLv6QgsJTBODUHC5Rak_PArA6gv2t7inJzNTP38,11352
+deepeval-3.8.2.dist-info/METADATA,sha256=SUHVBa7pgBKF2XG3L3c_cItJWvuCdAQxzQSctzeAezQ,18752
+deepeval-3.8.2.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+deepeval-3.8.2.dist-info/entry_points.txt,sha256=NoismUQfwLOojSGZmBrdcpwfaoFRAzUhBvZD3UwOKog,95
+deepeval-3.8.2.dist-info/RECORD,,