deepeval 3.6.5__py3-none-any.whl → 3.6.7__py3-none-any.whl

deepeval/__init__.py

@@ -1,24 +1,56 @@
+from __future__ import annotations
+
+import logging
 import os
-import warnings
 import re
+import warnings
 
-# load environment variables before other imports
+# IMPORTANT: load environment variables before other imports
 from deepeval.config.settings import autoload_dotenv, get_settings
 
+logging.getLogger("deepeval").addHandler(logging.NullHandler())
 autoload_dotenv()
 
-from ._version import __version__
-from deepeval.evaluate import evaluate, assert_test
-from deepeval.evaluate.compare import compare
-from deepeval.test_run import on_test_run_end, log_hyperparameters
-from deepeval.utils import login
-from deepeval.telemetry import *
+
+def _expose_public_api() -> None:
+    # All other imports must happen after env is loaded
+    # Do not do this at module level or ruff will complain with E402
+    global __version__, evaluate, assert_test, compare
+    global on_test_run_end, log_hyperparameters, login, telemetry
+
+    from ._version import __version__ as _version
+    from deepeval.evaluate import (
+        evaluate as _evaluate,
+        assert_test as _assert_test,
+    )
+    from deepeval.evaluate.compare import compare as _compare
+    from deepeval.test_run import (
+        on_test_run_end as _on_end,
+        log_hyperparameters as _log_hparams,
+    )
+    from deepeval.utils import login as _login
+    import deepeval.telemetry as _telemetry
+
+    __version__ = _version
+    evaluate = _evaluate
+    assert_test = _assert_test
+    compare = _compare
+    on_test_run_end = _on_end
+    log_hyperparameters = _log_hparams
+    login = _login
+    telemetry = _telemetry
+
+
+_expose_public_api()
 
 
 settings = get_settings()
+
 if not settings.DEEPEVAL_GRPC_LOGGING:
-    os.environ.setdefault("GRPC_VERBOSITY", "ERROR")
-    os.environ.setdefault("GRPC_TRACE", "")
+    if os.getenv("GRPC_VERBOSITY") is None:
+        os.environ["GRPC_VERBOSITY"] = settings.GRPC_VERBOSITY or "ERROR"
+    if os.getenv("GRPC_TRACE") is None:
+        os.environ["GRPC_TRACE"] = settings.GRPC_TRACE or ""
 
 
 __all__ = [

deepeval/_version.py

@@ -1 +1 @@
-__version__: str = "3.6.5"
+__version__: str = "3.6.7"

deepeval/benchmarks/equity_med_qa/equity_med_qa.py

@@ -121,6 +121,7 @@ class EquityMedQA(DeepEvalBaseBenchmark):
         score = metric.measure(
             LLMTestCase(input=golden.input, actual_output=prediction),
             _show_indicator=False,
+            _log_metric_to_confident=False,
         )
         flipped_score = (
             1 - metric.score if metric.score in [0, 1] else metric.score

deepeval/cli/main.py

@@ -328,6 +328,31 @@ def set_debug(
         "--trace-flush/--no-trace-flush",
         help="Enable / disable  CONFIDENT_TRACE_FLUSH.",
     ),
+    trace_sample_rate: Optional[float] = typer.Option(
+        None,
+        "--trace-sample-rate",
+        help="Set CONFIDENT_TRACE_SAMPLE_RATE.",
+    ),
+    metric_logging_verbose: Optional[bool] = typer.Option(
+        None,
+        "--metric-logging-verbose/--no-metric-logging-verbose",
+        help="Enable / disable CONFIDENT_METRIC_LOGGING_VERBOSE.",
+    ),
+    metric_logging_flush: Optional[bool] = typer.Option(
+        None,
+        "--metric-logging-flush/--no-metric-logging-flush",
+        help="Enable / disable CONFIDENT_METRIC_LOGGING_FLUSH.",
+    ),
+    metric_logging_sample_rate: Optional[float] = typer.Option(
+        None,
+        "--metric-logging-sample-rate",
+        help="Set CONFIDENT_METRIC_LOGGING_SAMPLE_RATE.",
+    ),
+    metric_logging_enabled: Optional[bool] = typer.Option(
+        None,
+        "--metric-logging-enabled/--no-metric-logging-enabled",
+        help="Enable / disable CONFIDENT_METRIC_LOGGING_ENABLED.",
+    ),
     # Advanced / potentially surprising
     error_reporting: Optional[bool] = typer.Option(
         None,
@@ -387,6 +412,20 @@ def set_debug(
             settings.CONFIDENT_TRACE_ENVIRONMENT = trace_env
         if trace_flush is not None:
             settings.CONFIDENT_TRACE_FLUSH = trace_flush
+        if trace_sample_rate is not None:
+            settings.CONFIDENT_TRACE_SAMPLE_RATE = trace_sample_rate
+
+        # Confident metrics
+        if metric_logging_verbose is not None:
+            settings.CONFIDENT_METRIC_LOGGING_VERBOSE = metric_logging_verbose
+        if metric_logging_flush is not None:
+            settings.CONFIDENT_METRIC_LOGGING_FLUSH = metric_logging_flush
+        if metric_logging_sample_rate is not None:
+            settings.CONFIDENT_METRIC_LOGGING_SAMPLE_RATE = (
+                metric_logging_sample_rate
+            )
+        if metric_logging_enabled is not None:
+            settings.CONFIDENT_METRIC_LOGGING_ENABLED = metric_logging_enabled
 
         # Advanced
         if error_reporting is not None:
@@ -438,6 +477,8 @@ def unset_debug(
         settings.LOG_LEVEL = "info"
         settings.CONFIDENT_TRACE_ENVIRONMENT = "development"
         settings.CONFIDENT_TRACE_VERBOSE = True
+        settings.CONFIDENT_METRIC_LOGGING_VERBOSE = True
+        settings.CONFIDENT_METRIC_LOGGING_ENABLED = True
 
         # Clear optional toggles/overrides
         settings.DEEPEVAL_VERBOSE_MODE = None
@@ -449,6 +490,7 @@ def unset_debug(
         settings.GRPC_TRACE = None
 
         settings.CONFIDENT_TRACE_FLUSH = None
+        settings.CONFIDENT_METRIC_LOGGING_FLUSH = None
 
         settings.ERROR_REPORTING = None
         settings.IGNORE_DEEPEVAL_ERRORS = None

deepeval/confident/api.py

@@ -87,6 +87,7 @@ class Endpoints(Enum):
     DATASET_ALIAS_QUEUE_ENDPOINT = "/v1/datasets/:alias/queue"
 
     TEST_RUN_ENDPOINT = "/v1/test-run"
+    METRIC_DATA_ENDPOINT = "/v1/metric-data"
     TRACES_ENDPOINT = "/v1/traces"
     ANNOTATIONS_ENDPOINT = "/v1/annotations"
     PROMPTS_VERSION_ID_ENDPOINT = "/v1/prompts/:alias/versions/:versionId"

deepeval/config/logging.py

@@ -0,0 +1,33 @@
+"""
+Minimal logging configuration helpers for DeepEval.
+
+This module centralizes how the library-level logger ("deepeval") is configured. We
+intentionally keep configuration lightweight so application code retains control
+over handlers and formatters.
+"""
+
+import logging
+from deepeval.config.settings import get_settings
+
+
+def apply_deepeval_log_level() -> None:
+    """
+    Apply DeepEval's current log level to the package logger.
+
+    This function reads `LOG_LEVEL` from `deepeval.config.settings.get_settings()`
+    and sets the level of the `"deepeval"` logger accordingly. If `LOG_LEVEL` is
+    unset (None), INFO is used as a default. The logger's `propagate` flag is set
+    to True so records bubble up to the application's handlers. DeepEval does not
+    install its own handlers here (a NullHandler is attached in `__init__.py`).
+
+    The function is idempotent and safe to call multiple times. It is invoked
+    automatically when settings are first constructed and whenever `LOG_LEVEL`
+    is changed via `settings.edit`.
+    """
+    settings = get_settings()
+    log_level = settings.LOG_LEVEL
+    logging.getLogger("deepeval").setLevel(
+        log_level if log_level is not None else logging.INFO
+    )
+    # ensure we bubble up to app handlers
+    logging.getLogger("deepeval").propagate = True

deepeval/config/settings.py

@@ -10,12 +10,20 @@ Central config for DeepEval.
 """
 
 import logging
+import math
 import os
 import re
 
 from dotenv import dotenv_values
 from pathlib import Path
-from pydantic import AnyUrl, SecretStr, field_validator, confloat
+from pydantic import (
+    AnyUrl,
+    computed_field,
+    confloat,
+    conint,
+    field_validator,
+    SecretStr,
+)
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing import Any, Dict, List, Optional, NamedTuple
 
@@ -155,7 +163,7 @@ class Settings(BaseSettings):
     #
 
     APP_ENV: str = "dev"
-    LOG_LEVEL: str = "info"
+    LOG_LEVEL: Optional[int] = None
     PYTHONPATH: str = "."
     CONFIDENT_REGION: Optional[str] = None
     CONFIDENT_OPEN_BROWSER: Optional[bool] = True
@@ -287,9 +295,33 @@ class Settings(BaseSettings):
     #
     # Retry Policy
     #
-    DEEPEVAL_SDK_RETRY_PROVIDERS: Optional[List[str]] = None
-    DEEPEVAL_RETRY_BEFORE_LOG_LEVEL: Optional[int] = None  # default -> INFO
+    # Controls how Tenacity retries provider calls when the SDK isn't doing its own retries.
+    # Key concepts:
+    # - attempts count includes the first call. e.g. 1 = no retries, 2 = one retry.
+    # - backoff sleeps follow exponential growth with a cap, plus jitter. Expected jitter
+    #   contribution is ~ JITTER/2 per sleep.
+    # - logging levels are looked up dynamically each attempt, so if you change LOG_LEVEL at runtime,
+    #   the retry loggers will honor it without restart.
+    DEEPEVAL_SDK_RETRY_PROVIDERS: Optional[List[str]] = (
+        None  # ["*"] to delegate all retries to SDKs
+    )
+    DEEPEVAL_RETRY_BEFORE_LOG_LEVEL: Optional[int] = (
+        None  # default is LOG_LEVEL if set, else INFO
+    )
     DEEPEVAL_RETRY_AFTER_LOG_LEVEL: Optional[int] = None  # default -> ERROR
+    DEEPEVAL_RETRY_MAX_ATTEMPTS: conint(ge=1) = (
+        2  # attempts = first try + retries
+    )
+    DEEPEVAL_RETRY_INITIAL_SECONDS: confloat(ge=0) = (
+        1.0  # first sleep before retry, if any
+    )
+    DEEPEVAL_RETRY_EXP_BASE: confloat(ge=1) = (
+        2.0  # exponential growth factor for sleeps
+    )
+    DEEPEVAL_RETRY_JITTER: confloat(ge=0) = 2.0  # uniform jitter
+    DEEPEVAL_RETRY_CAP_SECONDS: confloat(ge=0) = (
+        5.0  # cap for each backoff sleep
+    )
 
     #
     # Telemetry and Debug
@@ -305,10 +337,17 @@ class Settings(BaseSettings):
     SKIP_DEEPEVAL_MISSING_PARAMS: Optional[bool] = None
     DEEPEVAL_VERBOSE_MODE: Optional[bool] = None
     ENABLE_DEEPEVAL_CACHE: Optional[bool] = None
+
     CONFIDENT_TRACE_FLUSH: Optional[bool] = None
     CONFIDENT_TRACE_ENVIRONMENT: Optional[str] = "development"
     CONFIDENT_TRACE_VERBOSE: Optional[bool] = True
-    CONFIDENT_SAMPLE_RATE: Optional[float] = 1.0
+    CONFIDENT_TRACE_SAMPLE_RATE: Optional[float] = 1.0
+
+    CONFIDENT_METRIC_LOGGING_FLUSH: Optional[bool] = None
+    CONFIDENT_METRIC_LOGGING_VERBOSE: Optional[bool] = True
+    CONFIDENT_METRIC_LOGGING_SAMPLE_RATE: Optional[float] = 1.0
+    CONFIDENT_METRIC_LOGGING_ENABLED: Optional[bool] = True
+
     OTEL_EXPORTER_OTLP_ENDPOINT: Optional[AnyUrl] = None
 
     #
@@ -316,19 +355,93 @@ class Settings(BaseSettings):
     #
     MEDIA_IMAGE_CONNECT_TIMEOUT_SECONDS: float = 3.05
     MEDIA_IMAGE_READ_TIMEOUT_SECONDS: float = 10.0
+    # DEEPEVAL_PER_ATTEMPT_TIMEOUT_SECONDS: per-attempt timeout for provider calls enforced by our retry decorator.
+    # This timeout interacts with retry policy and the task level budget (DEEPEVAL_PER_TASK_TIMEOUT_SECONDS) below.
+    # If you leave this at 0/None, the computed outer budget defaults to 180s.
+    DEEPEVAL_PER_ATTEMPT_TIMEOUT_SECONDS: Optional[confloat(ge=0)] = (
+        None  # per-attempt timeout. Set 0/None to disable
+    )
 
     #
-    # Async Task Configuration
+    # Async Document Pipelines
     #
 
-    # Maximum time allowed for a single task to complete
-    DEEPEVAL_PER_TASK_TIMEOUT_SECONDS: int = (
-        300  # Set to float('inf') to disable timeout
-    )
+    DEEPEVAL_MAX_CONCURRENT_DOC_PROCESSING: conint(ge=1) = 2
+
+    #
+    # Async Task Configuration
+    #
+    DEEPEVAL_TIMEOUT_THREAD_LIMIT: conint(ge=1) = 128
+    DEEPEVAL_TIMEOUT_SEMAPHORE_WARN_AFTER_SECONDS: confloat(ge=0) = 5.0
+    # DEEPEVAL_PER_TASK_TIMEOUT_SECONDS is the outer time budget for one metric/task.
+    # It is computed from per-attempt timeout + retries/backoff unless you explicitly override it.
+    # - OVERRIDE = None or 0 -> auto compute as:
+    #     attempts * per_attempt_timeout + sum(backoff_sleeps) + ~jitter/2 per sleep + 1s safety
+    #   (If per_attempt_timeout is 0/None, the auto outer budget defaults to 180s.)
+    # - OVERRIDE > 0         -> use that exact value. A warning is logged if it is likely too small
+    #   to permit the configured attempts/backoff.
+    #
+    # Tip:
+    #   Most users only need to set DEEPEVAL_PER_ATTEMPT_TIMEOUT_SECONDS and DEEPEVAL_RETRY_MAX_ATTEMPTS.
+    #   Leave the outer budget on auto unless you have very strict SLAs.
+    DEEPEVAL_PER_TASK_TIMEOUT_SECONDS_OVERRIDE: Optional[conint(ge=0)] = None
 
     # Buffer time for gathering results from all tasks, added to the longest task duration
     # Increase if many tasks are running concurrently
-    DEEPEVAL_TASK_GATHER_BUFFER_SECONDS: int = 60
+    DEEPEVAL_TASK_GATHER_BUFFER_SECONDS: confloat(ge=0) = 60
+
+    ###################
+    # Computed Fields #
+    ###################
+
+    def _calc_auto_outer_timeout(self) -> int:
+        """Compute outer budget from per-attempt timeout + retries/backoff.
+        Never reference the computed property itself here.
+        """
+        attempts = self.DEEPEVAL_RETRY_MAX_ATTEMPTS or 1
+        timeout_seconds = float(self.DEEPEVAL_PER_ATTEMPT_TIMEOUT_SECONDS or 0)
+        if timeout_seconds <= 0:
+            # No per-attempt timeout set -> default outer budget
+            return 180
+
+        sleeps = max(0, attempts - 1)
+        cur = float(self.DEEPEVAL_RETRY_INITIAL_SECONDS)
+        cap = float(self.DEEPEVAL_RETRY_CAP_SECONDS)
+        base = float(self.DEEPEVAL_RETRY_EXP_BASE)
+        jitter = float(self.DEEPEVAL_RETRY_JITTER)
+
+        backoff = 0.0
+        for _ in range(sleeps):
+            backoff += min(cap, cur)
+            cur *= base
+        backoff += sleeps * (jitter / 2.0)  # expected jitter
+
+        safety_overhead = 1.0
+        return int(
+            math.ceil(attempts * timeout_seconds + backoff + safety_overhead)
+        )
+
+    @computed_field
+    @property
+    def DEEPEVAL_PER_TASK_TIMEOUT_SECONDS(self) -> int:
+        """If OVERRIDE is set (nonzero), return it; else return the derived budget."""
+        outer = self.DEEPEVAL_PER_TASK_TIMEOUT_SECONDS_OVERRIDE
+        if outer not in (None, 0):
+            # Warn if user-provided outer is likely to truncate retries
+            if (self.DEEPEVAL_PER_ATTEMPT_TIMEOUT_SECONDS or 0) > 0:
+                min_needed = self._calc_auto_outer_timeout()
+                if int(outer) < min_needed:
+                    if self.DEEPEVAL_VERBOSE_MODE:
+                        logger.warning(
+                            "Metric timeout (outer=%ss) is less than attempts × per-attempt "
+                            "timeout + backoff (≈%ss). Retries may be cut short.",
+                            int(outer),
+                            min_needed,
+                        )
+            return int(outer)
+
+        # Auto mode
+        return self._calc_auto_outer_timeout()
 
     ##############
     # Validators #
@@ -384,7 +497,8 @@ class Settings(BaseSettings):
         "OPENAI_COST_PER_INPUT_TOKEN",
         "OPENAI_COST_PER_OUTPUT_TOKEN",
         "TEMPERATURE",
-        "CONFIDENT_SAMPLE_RATE",
+        "CONFIDENT_TRACE_SAMPLE_RATE",
+        "CONFIDENT_METRIC_LOGGING_SAMPLE_RATE",
         mode="before",
     )
     @classmethod
@@ -396,13 +510,17 @@ class Settings(BaseSettings):
             return None
         return float(v)
 
-    @field_validator("CONFIDENT_SAMPLE_RATE")
+    @field_validator(
+        "CONFIDENT_TRACE_SAMPLE_RATE", "CONFIDENT_METRIC_LOGGING_SAMPLE_RATE"
+    )
     @classmethod
     def _validate_sample_rate(cls, v):
         if v is None:
             return None
         if not (0.0 <= float(v) <= 1.0):
-            raise ValueError("CONFIDENT_SAMPLE_RATE must be between 0 and 1")
+            raise ValueError(
+                "CONFIDENT_TRACE_SAMPLE_RATE or CONFIDENT_METRIC_LOGGING_SAMPLE_RATE must be between 0 and 1"
+            )
         return float(v)
 
     @field_validator("DEEPEVAL_DEFAULT_SAVE", mode="before")
@@ -474,7 +592,9 @@ class Settings(BaseSettings):
             if s in SUPPORTED_PROVIDER_SLUGS:
                 normalized.append(s)
             else:
-                if cls.DEEPEVAL_VERBOSE_MODE:
+                if parse_bool(
+                    os.getenv("DEEPEVAL_VERBOSE_MODE"), default=False
+                ):
                     logger.warning("Unknown provider slug %r dropped", item)
 
         if star:
@@ -487,6 +607,7 @@ class Settings(BaseSettings):
     @field_validator(
         "DEEPEVAL_RETRY_BEFORE_LOG_LEVEL",
         "DEEPEVAL_RETRY_AFTER_LOG_LEVEL",
+        "LOG_LEVEL",
         mode="before",
     )
     @classmethod
@@ -524,6 +645,10 @@ class Settings(BaseSettings):
     # Persistence support #
     #######################
     class _SettingsEditCtx:
+        COMPUTED_FIELDS: frozenset[str] = frozenset(
+            {"DEEPEVAL_PER_TASK_TIMEOUT_SECONDS"}
+        )
+
         def __init__(
             self,
             settings: "Settings",
@@ -559,8 +684,11 @@ class Settings(BaseSettings):
             # lazy import legacy JSON store deps
             from deepeval.key_handler import KEY_FILE_HANDLER
 
+            model_fields = type(self._s).model_fields
+            # Exclude computed fields from persistence
+
             # compute diff of changed fields
-            after = {k: getattr(self._s, k) for k in type(self._s).model_fields}
+            after = {k: getattr(self._s, k) for k in model_fields}
 
             before_norm = {
                 k: _normalize_for_env(v) for k, v in self._before.items()
@@ -570,12 +698,21 @@ class Settings(BaseSettings):
             changed_keys = {
                 k for k in after_norm if after_norm[k] != before_norm.get(k)
             }
+            changed_keys -= self.COMPUTED_FIELDS
+
             if not changed_keys:
                 self.result = PersistResult(False, None, {})
                 return False
 
             updates = {k: after[k] for k in changed_keys}
 
+            if "LOG_LEVEL" in updates:
+                from deepeval.config.logging import (
+                    apply_deepeval_log_level,
+                )
+
+                apply_deepeval_log_level()
+
             #
             # .deepeval JSON support
             #
@@ -681,4 +818,27 @@ def get_settings() -> Settings:
     global _settings_singleton
     if _settings_singleton is None:
         _settings_singleton = Settings()
+        from deepeval.config.logging import apply_deepeval_log_level
+
+        apply_deepeval_log_level()
     return _settings_singleton
+
+
+def reset_settings(*, reload_dotenv: bool = False) -> Settings:
+    """
+    Drop the cached Settings singleton and rebuild it from the current process
+    environment.
+
+    Args:
+        reload_dotenv: When True, call `autoload_dotenv()` before re-instantiating,
+                       which merges .env values into os.environ (never overwriting
+                       existing process env vars).
+
+    Returns:
+        The fresh Settings instance.
+    """
+    global _settings_singleton
+    if reload_dotenv:
+        autoload_dotenv()
+    _settings_singleton = None
+    return get_settings()

deepeval/constants.py

@@ -9,9 +9,16 @@ LOGIN_PROMPT = "\n✨👀 Looking for a place for your LLM test data to live
 
 CONFIDENT_TRACE_VERBOSE = "CONFIDENT_TRACE_VERBOSE"
 CONFIDENT_TRACE_FLUSH = "CONFIDENT_TRACE_FLUSH"
-CONFIDENT_SAMPLE_RATE = "CONFIDENT_SAMPLE_RATE"
+CONFIDENT_TRACE_SAMPLE_RATE = "CONFIDENT_TRACE_SAMPLE_RATE"
 CONFIDENT_TRACE_ENVIRONMENT = "CONFIDENT_TRACE_ENVIRONMENT"
 CONFIDENT_TRACING_ENABLED = "CONFIDENT_TRACING_ENABLED"
+
+CONFIDENT_METRIC_LOGGING_VERBOSE = "CONFIDENT_METRIC_LOGGING_VERBOSE"
+CONFIDENT_METRIC_LOGGING_FLUSH = "CONFIDENT_METRIC_LOGGING_FLUSH"
+CONFIDENT_METRIC_LOGGING_SAMPLE_RATE = "CONFIDENT_METRIC_LOGGING_SAMPLE_RATE"
+CONFIDENT_METRIC_LOGGING_ENABLED = "CONFIDENT_METRIC_LOGGING_ENABLED"
+
+
 CONFIDENT_OPEN_BROWSER = "CONFIDENT_OPEN_BROWSER"
 CONFIDENT_TEST_CASE_BATCH_SIZE = "CONFIDENT_TEST_CASE_BATCH_SIZE"
 

deepeval/dataset/dataset.py

@@ -49,7 +49,7 @@ from deepeval.utils import (
 from deepeval.test_run import (
     global_test_run_manager,
 )
-from deepeval.openai.utils import openai_test_case_pairs
+
 from deepeval.tracing import trace_manager
 from deepeval.tracing.tracing import EVAL_DUMMY_SPAN_NAME
 
@@ -1248,16 +1248,7 @@ class EvaluationDataset:
                         display_config.file_output_dir,
                     )
 
-            # update hyperparameters
-            test_run = global_test_run_manager.get_test_run()
-            if len(openai_test_case_pairs) > 0:
-                raw_hyperparameters = openai_test_case_pairs[-1].hyperparameters
-                test_run.hyperparameters = process_hyperparameters(
-                    raw_hyperparameters
-                )
-
-            # clean up
-            openai_test_case_pairs.clear()
+            # save test run
             global_test_run_manager.save_test_run(TEMP_FILE_PATH)
 
             # sandwich end trace for OTEL

deepeval/dataset/utils.py

@@ -120,7 +120,7 @@ def format_turns(turns: List[Turn]) -> str:
         }
         res.append(cur_turn)
     try:
-        return json.dumps(res)
+        return json.dumps(res, ensure_ascii=False)
     except Exception as e:
         raise ValueError(f"Error serializing turns: {e}")
 

deepeval/evaluate/evaluate.py

@@ -28,7 +28,10 @@ from deepeval.evaluate.utils import (
 from deepeval.dataset import Golden
 from deepeval.prompt import Prompt
 from deepeval.test_case.utils import check_valid_test_cases_type
-from deepeval.test_run.hyperparameters import process_hyperparameters
+from deepeval.test_run.hyperparameters import (
+    process_hyperparameters,
+    process_prompts,
+)
 from deepeval.test_run.test_run import TEMP_FILE_PATH
 from deepeval.utils import (
     get_or_create_event_loop,
@@ -267,6 +270,7 @@ def evaluate(
 
         test_run = global_test_run_manager.get_test_run()
         test_run.hyperparameters = process_hyperparameters(hyperparameters)
+        test_run.prompts = process_prompts(hyperparameters)
         global_test_run_manager.save_test_run(TEMP_FILE_PATH)
         res = global_test_run_manager.wrap_up_test_run(
             run_duration, display_table=False