ibm-watsonx-gov 1.3.3__cp313-cp313-win_amd64.whl

ibm_watsonx_gov/evaluators/agentic_traces_evaluator.py

@@ -0,0 +1,115 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from datetime import timedelta
+from typing import Annotated, Dict, Optional
+
+from pydantic import Field
+
+from ibm_watsonx_gov.entities.agentic_app import AgenticApp
+from ibm_watsonx_gov.entities.enums import MessageStatus, MetricGroup, MetricValueType
+from ibm_watsonx_gov.entities.evaluation_result import AgentMetricResult
+from ibm_watsonx_gov.entities.mapping import Mapping
+from ibm_watsonx_gov.evaluators.base_evaluator import BaseEvaluator
+from ibm_watsonx_gov.evaluators.impl.evaluate_metrics_impl import _evaluate_metrics
+from ibm_watsonx_gov.traces.span_util import flatten_attributes
+from ibm_watsonx_gov.traces.trace_utils import TraceUtils
+
+
+class AgenticTracesEvaluator(BaseEvaluator):
+    """
+    The class to evaluate agentic applications based on the traces generated.
+    """
+    agentic_app: Annotated[Optional[AgenticApp], Field(
+        title="Agentic application configuration details", description="The agentic application configuration details.", default=None)]
+
+    def compute_metrics(self, spans: list[dict], mapping: Mapping, **kwargs) -> list[AgentMetricResult]:
+        """
+        Computes the agentic metrics based on the spans/traces provided as a list.
+
+        Args:
+            spans (list[AgentMetricResult]): The spans on which the metrics need to be computed
+            mapping (Mapping): The various mappings for finding the metric inputs.
+
+        Returns:
+            list[AgentMetricResult]: The computed metric results
+        """
+        span_trees = TraceUtils.build_span_trees(
+            spans=spans, agentic_app=self.agentic_app)
+        metrics_result = []
+        for span_tree in span_trees:
+            # Process only the spans that are associated with the agent application
+            attrs = flatten_attributes(span_tree.span.attributes)
+            if not attrs.get("traceloop.span.kind") == "workflow":
+                continue
+
+            data = span_tree.get_values(mapping)
+
+            mr = self.compute_message_level_metrics(data, **kwargs)
+            metrics_result.extend(mr)
+
+        return metrics_result
+
+    def compute_message_level_metrics(self, data: Dict, **kwargs) -> list[AgentMetricResult]:
+        metric_results = []
+
+        start_time = data.get("start_time")
+        end_time = data.get("end_time")
+
+        if start_time is None or end_time is None:
+            raise Exception("start_time and/or end_time are missing.")
+
+        message_id = data.get("message_id")
+        conversation_id = data.get("conversation_id")
+
+        if message_id is None or conversation_id is None:
+            raise Exception(
+                "message_id and/or conversation_id are missing.")
+
+        duration: timedelta = (end_time - start_time)
+        duration = duration.total_seconds()
+
+        metric_results.append(AgentMetricResult(name="duration",
+                                                display_name="Message Duration",
+                                                value=duration,
+                                                group=MetricGroup.PERFORMANCE,
+                                                applies_to="message",
+                                                message_id=message_id,
+                                                conversation_id=conversation_id))
+
+        metric_results.append(AgentMetricResult(name="status",
+                                                display_name="Message Status",
+                                                value_type=MetricValueType.CATEGORICAL.value,
+                                                value=data.get(
+                                                    "status", MessageStatus.UNKNOWN.value),
+                                                group=MetricGroup.MESSAGE_COMPLETION,
+                                                applies_to="message",
+                                                message_id=message_id,
+                                                conversation_id=conversation_id))
+
+        if not self.agentic_app:
+            return metric_results
+
+        metric_result = _evaluate_metrics(configuration=self.agentic_app.metrics_configuration.configuration,
+                                          data=data,
+                                          metrics=self.agentic_app.metrics_configuration.metrics,
+                                          metric_groups=self.agentic_app.metrics_configuration.metric_groups,
+                                          api_client=kwargs.get("api_client"),
+                                          ignore_validation_errors=True).to_dict()
+        for mr in metric_result:
+            node_result = {
+                "applies_to": "message",
+                "message_id": message_id,
+                "conversation_id": conversation_id,
+                **mr
+            }
+
+            metric_results.append(AgentMetricResult(**node_result))
+
+        return metric_results

ibm_watsonx_gov/evaluators/base_evaluator.py

@@ -0,0 +1,22 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated
+
+from ibm_watsonx_gov.clients.api_client import APIClient
+
+
+class BaseEvaluator(BaseModel):
+    """
+    The base class for all evaluators.
+    """
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    api_client: Annotated[APIClient | None,
+                          Field(name="The IBM watsonx.governance client.", default=None)]

ibm_watsonx_gov/evaluators/metrics_evaluator.py

@@ -0,0 +1,187 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+import pandas as pd
+from pydantic import Field, PrivateAttr
+from typing_extensions import Annotated
+
+from ibm_watsonx_gov.config.gen_ai_configuration import GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup
+from ibm_watsonx_gov.entities.evaluation_result import MetricsEvaluationResult
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.evaluators.base_evaluator import BaseEvaluator
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+
+
+class MetricsEvaluator(BaseEvaluator):
+    """
+    The class to evaluate the metrics and display the results.
+
+    Examples:
+        1. Evaluate metrics by passing data as a dataframe and default configuration
+            .. code-block:: python
+
+                os.environ["WATSONX_APIKEY"] = "..."
+
+                evaluator = MetricsEvaluator()
+                df = pd.read_csv("")
+                metrics = [AnswerSimilarityMetric()]
+
+                result = evaluator.evaluate(data=df, metrics=metrics)
+
+        2. Evaluate metrics by passing data as a json and default configuration
+            .. code-block:: python
+
+                os.environ["WATSONX_APIKEY"] = "..."
+
+                evaluator = MetricsEvaluator()
+                json_data = {"input_text": "..."}
+                metrics=[HAPMetric()]
+
+                result = evaluator.evaluate(data=json_data, metrics=metrics)
+
+        3. Evaluate metrics by passing configuration and api_client
+            .. code-block:: python
+
+                config = GenAIConfiguration(input_fields=["question"],
+                                    context_fields=["context"],
+                                    output_fields=["generated_text"],
+                                    reference_fields=["reference_answer"])
+                wxgov_client = APIClient(credentials=Credentials(api_key=""))
+                evaluator = MetricsEvaluator(configuration=config, api_client=wxgov_client)
+                df = pd.read_csv("")
+                metrics = [AnswerSimilarityMetric()]
+
+                result = evaluator.evaluate(data=df, metrics=metrics)
+
+        4. Evaluate metrics by passing metric groups
+            .. code-block:: python
+
+                os.environ["WATSONX_APIKEY"] = "..."
+
+                evaluator = MetricsEvaluator()
+                df = pd.read_csv("")
+                metrics = [AnswerSimilarityMetric()]
+                metric_groups = [MetricGroup.RETRIEVAL_QUALITY]
+
+                result = evaluator.evaluate(data=df, metrics=metrics, metric_groups=metric_groups)
+
+        5. Display the results
+            .. code-block:: python
+
+                # Get the results in the required format from the output of the evaluate method
+                result.to_json()
+                result.to_df()
+                result.to_dict()
+
+                # Display the results
+                evaluator.display_table()
+                evaluator.display_insights()
+
+
+
+    """
+    configuration: Annotated[GenAIConfiguration,
+                             Field(title="Generative AI Configuration",
+                                   description="The configuration for metrics evaluation.",
+                                   default=GenAIConfiguration())]
+    _data: Annotated[pd.DataFrame | dict | None,
+                     PrivateAttr(default=None)]
+    _metrics: Annotated[list[GenAIMetric] | None,
+                        PrivateAttr(default=None)]
+    _metric_groups: Annotated[list[MetricGroup] | None,
+                              PrivateAttr(default=None)]
+    _result: Annotated[MetricsEvaluationResult | None,
+                       PrivateAttr(default=None)]
+
+    def evaluate(
+            self,
+            data: pd.DataFrame | dict,
+            metrics: list[GenAIMetric] = [],
+            metric_groups: list[MetricGroup] = [],
+            **kwargs) -> MetricsEvaluationResult:
+        """
+        Evaluate the metrics for the given data.
+
+        Args:
+            data (pd.DataFrame | dict): The data to be evaluated.
+            metrics (list[GenAIMetric], optional): The metrics to be evaluated. Defaults to [].
+            metric_groups (list[MetricGroup], optional): The metric groups to be evaluated. Defaults to [].
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            MetricsEvaluationResult: The result of the evaluation.
+        """
+        return run_in_event_loop(
+            self.evaluate_async,
+            data=data,
+            metrics=metrics,
+            metric_groups=metric_groups,
+            **kwargs,
+        )
+
+    async def evaluate_async(
+            self,
+            data: pd.DataFrame | dict,
+            metrics: list[GenAIMetric] = [],
+            metric_groups: list[MetricGroup] = [],
+            **kwargs
+    ) -> MetricsEvaluationResult:
+        """
+        asynchronously evaluate the metrics for the given data.
+
+        Args:
+            data (pd.DataFrame | dict): The data to be evaluated.
+            metrics (list[GenAIMetric], optional): The metrics to be evaluated. Defaults to [].
+            metric_groups (list[MetricGroup], optional): The metric groups to be evaluated. Defaults to [].
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            MetricsEvaluationResult: The result of the evaluation.
+        """
+        from ..evaluators.impl.evaluate_metrics_impl import (
+            _evaluate_metrics_async, _resolve_metric_dependencies)
+        self._data = data
+        self._metrics = _resolve_metric_dependencies(
+            metrics=metrics, metric_groups=metric_groups
+        )
+        self._metric_groups = metric_groups
+        self._result: MetricsEvaluationResult = await _evaluate_metrics_async(
+            configuration=self.configuration,
+            data=data,
+            metrics=self._metrics,
+            api_client=self.api_client,
+            **kwargs,
+        )
+        return self._result
+
+    def display_table(self):
+        """
+        Display the metrics result as a table.
+        """
+        try:
+            from ibm_watsonx_gov.visualizations import display_table
+        except:
+            ImportError(
+                "Please install the required dependencies 'ibm-watsonx-gov[visualization]' to display the results.")
+        display_table(self._result.to_df(data=self._data))
+
+    def display_insights(self):
+        """
+        Display the metrics result in a venn diagram based on the metrics threshold.
+        """
+        try:
+            from ibm_watsonx_gov.visualizations import ModelInsights
+        except:
+            ImportError(
+                "Please install the required dependencies 'ibm-watsonx-gov[visualization]' to display the results.")
+        model_insights = ModelInsights(
+            configuration=self.configuration, metrics=self._metrics)
+        model_insights.display_metrics(
+            metrics_result=self._result.to_df(data=self._data))

ibm_watsonx_gov/evaluators/model_risk_evaluator.py

@@ -0,0 +1,89 @@
+
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+
+from ibm_watsonx_gov.clients.api_client import APIClient
+from ibm_watsonx_gov.config.model_risk_configuration import \
+    ModelRiskConfiguration
+from ibm_watsonx_gov.entities.model_risk_result import ModelRiskResult
+from ibm_watsonx_gov.evaluators.base_evaluator import BaseEvaluator
+from IPython.display import display
+from pydantic import Field, PrivateAttr
+from typing_extensions import Annotated
+
+
+class ModelRiskEvaluator(BaseEvaluator):
+    """
+    The class to evaluate the foundational model risk and display the results.
+
+    Example:
+        1. Basic usage
+            .. code-block:: python
+
+                configuration = ModelRiskConfiguration(
+                    model_details=model_details,
+                    risk_dimensions=risk_dimensions,
+                    max_sample_size=max_sample_size,
+                    pdf_report_output_path=pdf_report_output_path
+                )
+                wxgov_client = APIClient(credentials=Credentials(api_key=""))
+                evaluator = ModelRiskEvaluator(
+                    configuration=config, api_client=wxgov_client)
+
+                result = evaluator.evaluate()
+
+                # Get the results in the required format
+                result.to_json()
+
+                # Display the results
+                evaluator.display_table()
+                evaluator.download_model_risk_report()
+    """
+    configuration: Annotated[ModelRiskConfiguration,
+                             Field(name="The configuration for model risk evaluation.")]
+    api_client: Annotated[APIClient | None,
+                          Field(name="The IBM watsonx.governance client.", default=None)]
+
+    _result: Annotated[ModelRiskResult | None,
+                       PrivateAttr(default=None)]
+
+    def evaluate(self) -> ModelRiskResult:
+        """
+        Evaluates the risk of a Foundation model.
+
+        Returns:
+            ModelRiskResult: The result of the model risk evaluation.
+        """
+        from ibm_watsonx_gov.evaluators.impl.evaluate_model_risk_impl import \
+            _evaluate_model_risk
+
+        self._result = _evaluate_model_risk(
+            self.configuration,
+            self.api_client,
+        )
+
+        return self._result
+
+    def display_table(self):
+        for risk in self._result.risks:
+            print(f"\n--- Risk: {risk.name} ---")
+            for benchmark in risk.benchmarks:
+                print(f"Benchmark: {benchmark.name}")
+                display(benchmark.get_metric_df())
+
+    def download_model_risk_report(self):
+        """
+        Downloads the model risk report and returns the download link.
+        """
+        from ibm_wos_utils.joblib.utils.notebook_utils import \
+            create_download_link_for_file
+
+        return create_download_link_for_file(
+            self._result.output_file_path)

ibm_watsonx_gov/evaluators/traces_evaluator.py

@@ -0,0 +1,93 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from typing import Annotated
+
+from pydantic import Field, PrivateAttr
+
+from ibm_watsonx_gov.entities.agentic_app import AgenticApp, Node
+from ibm_watsonx_gov.entities.agentic_evaluation_result import \
+    AgenticEvaluationResult
+from ibm_watsonx_gov.evaluators.base_evaluator import BaseEvaluator
+from ibm_watsonx_gov.traces.span_util import flatten_attributes
+from ibm_watsonx_gov.traces.trace_utils import TraceUtils
+from ibm_watsonx_gov.utils.aggregation_util import \
+    get_agentic_evaluation_result
+from ibm_watsonx_gov.utils.async_util import (gather_with_concurrency,
+                                              run_in_event_loop)
+from ibm_watsonx_gov.utils.python_utils import add_if_unique
+
+
+class TracesEvaluator(BaseEvaluator):
+    """
+    The class to evaluate agentic applications based on the traces generated.
+    """
+    agentic_app: Annotated[AgenticApp,
+                           Field(title="Agentic application configuration details",
+                                 description="The agentic application configuration details.")]
+    __nodes: Annotated[list[Node], PrivateAttr(default=[])]
+
+    def evaluate(self, spans: list[dict], **kwargs) -> AgenticEvaluationResult:
+        """
+        Computes the agentic metrics based on the spans/traces provided as a list.
+
+        Args:
+            spans (list[AgentMetricResult]): The spans on which the metrics need to be computed.
+
+        Returns:
+            list[AgentMetricResult]: The computed metric results
+        """
+        metrics_result = []
+        node_data = []
+        messages_data = []
+        mapping_data = []
+        coros = []
+        max_concurrency = kwargs.get("max_concurrency", 10)
+        span_trees = TraceUtils.build_span_trees(
+            spans=spans, agentic_app=self.agentic_app)
+        for span_tree in span_trees:
+            # Process only the spans that are associated with the agent application
+            attrs = flatten_attributes(span_tree.span.attributes)
+            if not attrs.get("traceloop.span.kind") == "workflow":
+                continue
+
+            # Append coroutine for data
+            coros.append(
+                TraceUtils.compute_metrics_from_trace_async_v2(span_tree=span_tree,
+                                                               message_io_mapping=self.agentic_app.message_io_mapping,
+                                                               metrics_configuration=self.agentic_app.metrics_configuration,
+                                                               api_client=self.api_client, **kwargs
+                                                               )
+            )
+        # Run all coroutines in parallel with concurrency control
+        results = run_in_event_loop(
+            gather_with_concurrency,
+            coros=coros,
+            max_concurrency=max_concurrency)
+
+      # Process results
+        for mr, md, nd, mpd, ns in results:
+            metrics_result.extend(mr)
+            messages_data.append(md)
+            node_data.extend(nd)
+            mapping_data.append(mpd)
+
+            for n in ns:
+                add_if_unique(n, self.__nodes, ["name", "func_name"], [
+                              "foundation_models"])
+
+        result = get_agentic_evaluation_result(
+            metrics_result=metrics_result, nodes=self.__nodes)
+
+        result.messages_data = messages_data
+        result.nodes_data = node_data
+        result.metrics_mapping_data = mapping_data
+        result.nodes = self.__nodes
+
+        return result

ibm_watsonx_gov/metric_groups/answer_quality/answer_quality_decorator.py

@@ -0,0 +1,66 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields, MetricGroup
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics import (AnswerRelevanceMetric,
+                                     AnswerSimilarityMetric,
+                                     FaithfulnessMetric,
+                                     UnsuccessfulRequestsMetric)
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+
+
+class AnswerQualityDecorator(BaseMetricDecorator):
+    def evaluate_answer_quality(self,
+                                func: Optional[Callable] = None,
+                                *,
+                                configuration: Optional[AgenticAIConfiguration] = None,
+                                metrics: list[GenAIMetric] = []
+                                ) -> dict:
+        """
+        An evaluation decorator for computing answer quality metrics on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_answer_quality, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = MetricGroup.ANSWER_QUALITY.get_metrics()
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(AnswerRelevanceMetric, FaithfulnessMetric, UnsuccessfulRequestsMetric, AnswerSimilarityMetric))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS,
+                                 EvaluatorFields.CONTEXT_FIELDS]
+                metric_outputs = [EvaluatorFields.OUTPUT_FIELDS]
+                metric_references = [EvaluatorFields.REFERENCE_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=metric_outputs,
+                                                      metric_references=metric_references,
+                                                      metric_groups=[MetricGroup.ANSWER_QUALITY])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating answer quality metrics on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metric_groups/content_safety/content_safety_decorator.py

@@ -0,0 +1,76 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields, MetricGroup
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics import (HAPMetric, PIIMetric,
+                                     PromptSafetyRiskMetric)
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics.evasiveness.evasiveness_metric import \
+    EvasivenessMetric
+from ibm_watsonx_gov.metrics.harm.harm_metric import HarmMetric
+from ibm_watsonx_gov.metrics.harm_engagement.harm_engagement_metric import \
+    HarmEngagementMetric
+from ibm_watsonx_gov.metrics.jailbreak.jailbreak_metric import JailbreakMetric
+from ibm_watsonx_gov.metrics.profanity.profanity_metric import ProfanityMetric
+from ibm_watsonx_gov.metrics.sexual_content.sexual_content_metric import \
+    SexualContentMetric
+from ibm_watsonx_gov.metrics.social_bias.social_bias_metric import \
+    SocialBiasMetric
+from ibm_watsonx_gov.metrics.unethical_behavior.unethical_behavior_metric import \
+    UnethicalBehaviorMetric
+from ibm_watsonx_gov.metrics.violence.violence_metric import ViolenceMetric
+
+
+class ContentSafetyDecorator(BaseMetricDecorator):
+    def evaluate_content_safety(self,
+                                func: Optional[Callable] = None,
+                                *,
+                                configuration: Optional[AgenticAIConfiguration] = None,
+                                metrics: list[GenAIMetric] = []
+                                ) -> dict:
+        """
+        An evaluation decorator for computing content safety metrics on an agentic node.
+        """
+
+        if func is None:
+            return partial(self.evaluate_content_safety, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = MetricGroup.CONTENT_SAFETY.get_metrics()
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(PromptSafetyRiskMetric, HAPMetric, PIIMetric, HarmMetric, SocialBiasMetric, ProfanityMetric, SexualContentMetric,
+                                                  UnethicalBehaviorMetric, ViolenceMetric, HarmEngagementMetric, EvasivenessMetric, JailbreakMetric))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=[],
+                                                      metric_groups=[MetricGroup.CONTENT_SAFETY])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating content safety metrics on {func.__name__},") from ex
+
+        return wrapper(func)