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

ibm_watsonx_gov/metrics/input_token_count/input_token_count_metric.py

@@ -0,0 +1,112 @@
+# ----------------------------------------------------------------------------------------------------
+# 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, Literal
+
+import pandas as pd
+import re
+from pydantic import Field
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration, GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import (AggregateMetricResult,
+                                                        RecordMetricResult)
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.utils.validation_util import validate_field
+
+INPUT_TOKEN_COUNT = "input_token_count"
+INPUT_TOKEN_COUNT_DISPLAY_NAME = "Input Token Count"
+
+
+class InputTokenCountResult(RecordMetricResult):
+    name: str = INPUT_TOKEN_COUNT
+    display_name: str = INPUT_TOKEN_COUNT_DISPLAY_NAME
+
+
+class InputTokenCountMetric(GenAIMetric):
+    """
+    Defines the Input token count metric class.
+
+    The Input token count metric keep track of LLM input token count.
+
+    Examples:
+        1. Create Cost metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = InputTokenCountMetric()
+                result = MetricsEvaluator().evaluate(data={"prompt_tokens": "..."},
+                                                    metrics=[metric])
+    """
+    name: Annotated[Literal["input_token_count"],
+                    Field(title="name",
+                          description="The input token count metric name.",
+                          default=INPUT_TOKEN_COUNT, frozen=True)]
+    display_name: Annotated[Literal["Input Token Count"],
+                            Field(title="Display Name",
+                                  description="The input token count metric display name.",
+                                  default=INPUT_TOKEN_COUNT_DISPLAY_NAME, frozen=True)]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=TaskType.values(), frozen=True)]
+    group: Annotated[MetricGroup,
+                     Field(title="Group",
+                           description="The metric group.",
+                           default=MetricGroup.USAGE, frozen=True)]
+
+    def evaluate(
+            self,
+            data: pd.DataFrame,
+            configuration: GenAIConfiguration | AgenticAIConfiguration,
+            **kwargs,
+    ) -> list[AggregateMetricResult]:
+        from ibm_watsonx_gov.utils.aggregation_util import get_summaries
+
+        validate_field("input_token_count_fields", configuration)
+        record_ids = data[configuration.record_id_field].to_list()
+        data = data.fillna(0)
+        input_tokens = self._evaluate(data, configuration)
+        record_level_metrics = [
+            InputTokenCountResult(record_id=record_id,
+                                  value=token, group=MetricGroup.USAGE.value)
+            for token, record_id in zip(input_tokens, record_ids)
+        ]
+        summary = get_summaries(input_tokens)
+        aggregate_metric_scores = AggregateMetricResult(
+            name=self.name,
+            display_name=self.display_name,
+            group=self.group,
+            min=summary.get("min"),
+            max=summary.get("max"),
+            mean=summary.get("mean"),
+            value=summary.get("mean"),
+            total_records=len(record_level_metrics),
+            record_level_metrics=record_level_metrics,
+        )
+
+        return aggregate_metric_scores
+
+    def _evaluate(self, data: pd.DataFrame, config: GenAIConfiguration | AgenticAIConfiguration) -> list:
+        """
+        Track total input token.
+        """
+        matched_cols = []
+
+        for pattern in config.input_token_count_fields:
+            # Compile regex pattern for safety and performance
+            regex = re.compile(pattern)
+            # Filter columns matching this pattern
+            matched = [col for col in data.columns if regex.fullmatch(col)]
+            matched_cols.extend(matched)
+
+        # Remove duplicates in case multiple patterns match the same column
+        matched_cols = list(set(matched_cols))
+
+        # Sum across these columns row-wise
+        return data[matched_cols].sum(axis=1).tolist()

ibm_watsonx_gov/metrics/jailbreak/__init__.py

@@ -0,0 +1,8 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------------------------

ibm_watsonx_gov/metrics/jailbreak/jailbreak_decorator.py

@@ -0,0 +1,60 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics.jailbreak.jailbreak_metric import JailbreakMetric
+
+
+class JailbreakDecorator(BaseMetricDecorator):
+
+    def evaluate_jailbreak(self,
+                           func: Optional[Callable] = None,
+                           *,
+                           configuration: Optional[AgenticAIConfiguration] = None,
+                           metrics: list[GenAIMetric] = []
+                           ) -> dict:
+        """
+        An evaluation decorator for computing jailbreak on an agentic node via granite guardian.
+        """
+        if func is None:
+            return partial(self.evaluate_jailbreak, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [JailbreakMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(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=[])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating jailbreak on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/jailbreak/jailbreak_metric.py

@@ -0,0 +1,103 @@
+# ----------------------------------------------------------------------------------------------------
+# 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, Literal
+
+import pandas as pd
+from pydantic import Field
+
+from ibm_watsonx_gov.config.gen_ai_configuration import GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import AggregateMetricResult
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.providers.detectors_provider import DetectorsProvider
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+from ibm_watsonx_gov.utils.validation_util import validate_input
+
+JAILBREAK = "jailbreak"
+
+
+class JailbreakMetric(GenAIMetric):
+    """
+    Defines the Jailbreak metric class.
+
+    The Jailbreak metric measures the risk of deliberate circumvention of AI systems built-in safeguards or ethical guidelines. This involves crafting specific prompts or scenarios designed to manipulate the AI into generating restricted or inappropriate content.
+    It is computed using the granite guardian model.
+
+    Examples:
+        1. Create Jailbreak metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = JailbreakMetric()
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", metrics=[metric])
+
+        2. Create Jailbreak metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="lower_limit", value=0.5)
+                metric = JailbreakMetric(threshold=threshold)
+    """
+    name: Annotated[Literal["jailbreak"],
+                    Field(title="Name",
+                          description="The jailbreak metric name.",
+                          default=JAILBREAK, frozen=True)]
+    display_name: Annotated[Literal["Jailbreak"],
+                            Field(title="Display Name",
+                                  description="The jailbreak metric display name.",
+                                  default="Jailbreak", frozen=True)]
+    method: Annotated[Literal["granite_guardian"],
+                      Field(title="Method",
+                            description="The method used to compute harm metric.",
+                            default="granite_guardian")]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=TaskType.values(), frozen=True)]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="upper_limit", value=0.5)])]
+    group: Annotated[MetricGroup,
+                     Field(title="Group",
+                           description="The metric group.",
+                           default=MetricGroup.CONTENT_SAFETY, frozen=True)]
+
+    async def evaluate_async(
+        self,
+        data: pd.DataFrame,
+        configuration: GenAIConfiguration,
+        **kwargs
+    ) -> list[AggregateMetricResult]:
+
+        validate_input(data.columns.to_list(), configuration)
+        kwargs["detector_params"] = {"risk_name": JAILBREAK}
+        provider = DetectorsProvider(configuration=configuration,
+                                     metric_name=self.name,
+                                     metric_display_name=self.display_name,
+                                     metric_method=self.method,
+                                     metric_group=self.group,
+                                     thresholds=self.thresholds,
+                                     **kwargs)
+        aggregated_metric_result = await provider.evaluate_async(data=data)
+        return aggregated_metric_result
+
+    def evaluate(
+        self,
+        data: pd.DataFrame | dict,
+        configuration: GenAIConfiguration,
+        **kwargs,
+    ):
+        # If ran in sync mode, block until it is done
+        return run_in_event_loop(
+            self.evaluate_async,
+            data=data,
+            configuration=configuration,
+            **kwargs,
+        )

ibm_watsonx_gov/metrics/keyword_detection/keyword_detection_decorator.py

@@ -0,0 +1,58 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics.keyword_detection.keyword_detection_metric import \
+    KeywordDetectionMetric
+
+
+class KeywordDetectionDecorator(BaseMetricDecorator):
+
+    def evaluate_keyword_detection(self,
+                                   func: Optional[Callable] = None,
+                                   *,
+                                   configuration: Optional[AgenticAIConfiguration] = None,
+                                   metrics: list[GenAIMetric]
+                                   ) -> dict:
+        """
+        An evaluation decorator for computing keyword detection on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_keyword_detection, configuration=configuration, metrics=metrics)
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(KeywordDetectionMetric,))
+
+                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=[])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating keyword detection on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/keyword_detection/keyword_detection_metric.py

@@ -0,0 +1,111 @@
+# ----------------------------------------------------------------------------------------------------
+# 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, Literal
+
+import pandas as pd
+from pydantic import Field
+
+from ibm_watsonx_gov.config.gen_ai_configuration import GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import AggregateMetricResult
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.providers.detectors_provider import DetectorsProvider
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+from ibm_watsonx_gov.utils.validation_util import validate_input
+
+KEYWORD = "keyword"
+
+
+class KeywordDetectionMetric(GenAIMetric):
+    """
+    Defines the Keyword Detection metric class.
+
+    The Keyword detection metric detects specific keyword(s) when they are mentioned explicitly in natural language.
+
+    Examples:
+        1. Create keyword detection metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = KeywordDetectionMetric(case_sensitive=True, keywords=["..."])
+                result = MetricsEvaluator().evaluate(data={"input_text": "..."}, metrics=[metric])
+
+        2. Create Keyword detection metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="upper_limit", value=0)
+                metric = KeywordDetectionMetric(threshold=threshold, keywords=["..."])
+    """
+    name: Annotated[Literal["keyword_detection"],
+                    Field(title="Name",
+                          description="The keyword detection metric name.",
+                          default="keyword_detection", frozen=True)]
+    display_name: Annotated[Literal["Keyword Detection"],
+                            Field(title="Display Name",
+                                  description="The keyword metric display name.",
+                                  default="Keyword Detection", frozen=True)]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=TaskType.values(), frozen=True)]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="upper_limit", value=0)])]
+    # group: Annotated[MetricGroup,
+    #                  Field(title="Group",
+    #                        description="The metric group.",
+    #                        default=MetricGroup.CONTENT_SAFETY, frozen=True)]
+
+    case_sensitive: Annotated[bool, Field(title="Case Sensitive",
+                                          default=False,
+                                          description="Specifies whether keyword matching is case-sensitive. If enabled, matches will be case-sensitive.")]
+
+    keywords: Annotated[list[str], Field(title="Keyword Strings",
+                                         default=None,
+                                         description=f"List of keywords to match against the input text.")]
+
+    async def evaluate_async(
+            self,
+            data: pd.DataFrame,
+            configuration: GenAIConfiguration,
+            **kwargs
+    ) -> list[AggregateMetricResult]:
+        if not self.keywords:
+            raise AssertionError(
+                f"The keywords field is required, but was missing from the input.")
+
+        validate_input(data.columns.to_list(), configuration)
+        kwargs["detector_params"] = {"case_sensitive": self.case_sensitive,
+                                     "keywords": self.keywords}
+
+        provider = DetectorsProvider(configuration=configuration,
+                                     metric_name=KEYWORD,
+                                     metric_display_name=self.display_name,
+                                     metric_method=self.method,
+                                     metric_group=MetricGroup.CONTENT_SAFETY,
+                                     thresholds=self.thresholds,
+                                     **kwargs)
+        aggregated_metric_result = await provider.evaluate_async(data=data)
+        return aggregated_metric_result
+
+    def evaluate(
+        self,
+        data: pd.DataFrame | dict,
+        configuration: GenAIConfiguration,
+        **kwargs,
+    ):
+        # If ran in sync mode, block until it is done
+        return run_in_event_loop(
+            self.evaluate_async,
+            data=data,
+            configuration=configuration,
+            **kwargs,
+        )

ibm_watsonx_gov/metrics/llm_validation/__init__.py

@@ -0,0 +1,8 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------------------------

ibm_watsonx_gov/metrics/llm_validation/evaluation_criteria.py

@@ -0,0 +1,84 @@
+# ----------------------------------------------------------------------------------------------------
+# 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 dataclasses import dataclass
+from typing import Dict, List
+
+
+@dataclass
+class EvaluationCriterion:
+    name: str = None
+    description: str = None
+
+    def __post_init__(self):
+        if not isinstance(self.name, str):
+            raise TypeError(
+                f"name must be str, got {type(self.name).__name__}")
+        if not isinstance(self.description, str):
+            raise TypeError(
+                f"description must be str, got {type(self.description).__name__}")
+
+    @classmethod
+    def from_dict(cls, criterion_dict):
+        if "name" not in criterion_dict:
+            raise ValueError(
+                f"criterion_dict must contain key 'name', got {criterion_dict}")
+        if "description" not in criterion_dict:
+            raise ValueError(
+                f"criterion_dict must contain key 'description', got {criterion_dict}")
+        return cls(criterion_dict.get("name"), criterion_dict.get("description"))
+
+    def to_str(self):
+        return f"{self.name}: {self.description}"
+
+    def to_dict(self):
+        return {"name": self.name, "description": self.description}
+
+
+@dataclass
+class EvaluationCriteria:
+    criteria_list: List[EvaluationCriterion]
+
+    @classmethod
+    def from_dict(cls, criteria_dict: Dict[str, str]):
+        """ create from dictionary: {"name":"value"} """
+        criteria_list = [EvaluationCriterion.from_dict({"name": name, "description": description})
+                         for name, description in criteria_dict.items()]
+        return cls(criteria_list)
+
+    @classmethod
+    def from_list_of_dicts(cls, criteria_dict: List[Dict[str, str]]):
+        """ create from dictionary. each dict should be of format: {"name":"...", "description":""}"""
+        criteria_list = [EvaluationCriterion.from_dict(
+            d) for d in criteria_dict]
+        return cls(criteria_list)
+
+    def to_str(self):
+        return "\n".join(c.to_str() for c in self.criteria_list)
+
+    def to_list_of_dicts(self):
+        return [c.to_dict() for c in self.criteria_list]
+
+    def to_dict(self):
+        return {c.name: c.description for c in self.criteria_list}
+
+
+def get_default_evaluation_criteria():
+    return EvaluationCriteria.from_dict(default_eval_criteria_dict)
+
+
+default_eval_criteria_dict = {
+    "Adherence to Instructions and Relevance":
+        "Does the model follow the given instructions (if any) and provide a relevant response to the input?",
+    "Accuracy & Completeness":
+        "Is the response factually correct (if applicable) and does it fully address the input's request without "
+        "omitting critical details?",
+    "Coherence & Clarity":
+        "Does the response make sense, follow a logical flow, and is it easy to understand?",
+}

ibm_watsonx_gov/metrics/llm_validation/llm_validation_constants.py

@@ -0,0 +1,24 @@
+# ----------------------------------------------------------------------------------------------------
+# 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 enum import Enum
+
+LLMValidation = "llm_validation"
+max_eval_text_for_synthesis = 150
+min_recurrent_evaluation_issues =  5
+
+class LLMValidationFields(Enum):
+    INPUT_FIELD = "model_prompt"
+    OUTPUT_FIELD = "model_output"
+    TEXT_FIELD = "evaluation_text"
+    SCORE_FIELD = "evaluation_score"
+    SUMMARY_FIELD = "evaluation_summary"
+    RECURRING_ISSUE_FIELD = "recurring_issues"
+    RECURRING_ISSUE_IDS_FIELD = "recurring_issues_ids"
+    EVALUATION_CRITERIA_FIELD = "evaluation_criteria"

ibm_watsonx_gov/metrics/llm_validation/llm_validation_decorator.py

@@ -0,0 +1,54 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics import LLMValidationMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+
+
+class LLMValidationDecorator(BaseMetricDecorator):
+    def evaluate_general_quality_with_llm(self,
+                              func: Optional[Callable] = None,
+                              *,
+                              configuration: Optional[AgenticAIConfiguration] = None,
+                              metrics: list[GenAIMetric],
+                              ) -> dict:
+        if func is None:
+            return partial(self.evaluate_general_quality_with_llm, configuration=configuration, metrics=metrics)
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                                valid_metric_types=(LLMValidationMetric,))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS]
+                metric_outputs = [EvaluatorFields.OUTPUT_FIELDS, EvaluatorFields.PROMPT_FIELD]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                        configuration=configuration,
+                                                        metrics=metrics,
+                                                        metric_inputs=metric_inputs,
+                                                        metric_outputs=metric_outputs)
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating evaluate_general_quality_with_llm metric on {func.__name__},") from ex
+
+        return wrapper(func)