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

ibm_watsonx_gov/metrics/tool_call_relevance/tool_call_relevance_metric.py

@@ -0,0 +1,166 @@
+# ----------------------------------------------------------------------------------------------------
+# 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 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
+from ibm_watsonx_gov.entities.llm_judge import LLMJudge
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.providers.tool_call_metric_provider import \
+    ToolCallMetricProvider
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+from ibm_watsonx_gov.utils.gov_sdk_logger import GovSDKLogger
+from ibm_watsonx_gov.utils.validation_util import (validate_input,
+                                                   validate_llm_as_judge,
+                                                   validate_tool_calls)
+from pydantic import Field
+
+logger = GovSDKLogger.get_logger(__name__)
+TOOL_CALL_RELEVANCE = "tool_call_relevance"
+
+
+class ToolCallRelevanceMetric(GenAIMetric):
+    """
+    ToolCallRelevanceMetric assesses whether this function call correctly implements 
+    the user's immediate request as the appropriate next step in the conversation. 
+    Compares against all available functions in the tool inventory to determine if 
+    the selection aligns with user intent and context.
+
+    The ToolCallRelevanceMetric will be computed using llm_as_judge.
+
+    Examples:
+        1. Create ToolCallRelevanceMetric by passing the basic configuration.
+            .. code-block:: python
+
+                config = GenAIConfiguration(tools = [get_weather,fetch_stock_price])
+                evaluator = MetricsEvaluator(configuration=config)
+                df = pd.read_csv("")
+                llm_judge = LLMJudge(
+                        model=WxAIFoundationModel(
+                            model_id="meta-llama/llama-3-3-70b-instruct",
+                            project_id=os.getenv("WATSONX_PROJECT_ID"),
+                        )
+                    )
+                metrics = [ToolCallRelevanceMetric(llm_judge=llm_judge)]
+                result = evaluator.evaluate(data=df, metrics=metrics)
+
+        2. Create ToolCallRelevanceMetric by passing custom tool calls field in configuration.
+            .. code-block:: python
+
+                config = GenAIConfiguration(tools = [get_weather,fetch_stock_price],
+                                            tool_calls_field="tools_used")
+                evaluator = MetricsEvaluator(configuration=config)
+                df = pd.read_csv("")
+                llm_judge = LLMJudge(
+                        model=WxAIFoundationModel(
+                            model_id="meta-llama/llama-3-3-70b-instruct",
+                            project_id=os.getenv("WATSONX_PROJECT_ID"),
+                        )
+                    )
+                metrics = [ToolCallRelevanceMetric(llm_judge=llm_judge)]
+                result = evaluator.evaluate(data=df, metrics=metrics)
+
+        3. Create ToolCallRelevanceMetric with a custom threshold.
+            .. code-block:: python
+
+                llm_judge = LLMJudge(
+                        model=WxAIFoundationModel(
+                            model_id="meta-llama/llama-3-3-70b-instruct",
+                            project_id=os.getenv("WATSONX_PROJECT_ID"),
+                        )
+                    )
+                threshold  = MetricThreshold(type="upper_limit", value=0.8)
+                metric = ToolCallRelevanceMetric(llm_judge=llm_judge, threshold=threshold)
+
+    """
+
+    name: Annotated[Literal["tool_call_relevance"], Field(title="Metric Name",
+                                                          description="The name of metric.",
+                                                          default=TOOL_CALL_RELEVANCE)]
+    display_name: Annotated[Literal["Tool Call Relevance"], Field(title="Display Name",
+                                                                  description="The tool call relevance metric display name.",
+                                                                  default="Tool Call Relevance", frozen=True)]
+    tasks: Annotated[list[TaskType], Field(title="Task Type",
+                                           description="The generative task type.",
+                                           default=[TaskType.RAG])]
+    group: Annotated[MetricGroup, Field(
+        default=MetricGroup.TOOL_CALL_QUALITY, frozen=True)]
+
+    llm_judge: Annotated[LLMJudge | None, Field(
+        description="The LLM judge used to compute the metric.", default=None)]
+
+    method: Annotated[Literal["llm_as_judge"], Field(title="Computation Method",
+                                                           description="The method used to compute the metric.",
+                                                           default="llm_as_judge")]
+    thresholds: Annotated[list[MetricThreshold], Field(title="Metric threshold",
+                                                       description="Value that defines the violation limit for the metric",
+                                                       default=[MetricThreshold(
+                                                           type="lower_limit", value=0.8)]
+                                                       )]
+    metric_mapping_name: Annotated[Literal["function_selection_appropriateness"], Field(title="Metric Mapping Name",
+                                                                                        description="The mapping name of metric with llmevalkit.",
+                                                                                        default="function_selection_appropriateness")]
+
+    async def evaluate_async(self, data: pd.DataFrame,
+                             configuration: GenAIConfiguration | AgenticAIConfiguration,
+                             **kwargs) -> AggregateMetricResult:
+        """
+        Evaluate the data for ToolCallRelevanceMetric
+        Args:
+            data (pd.DataFrame | dict): Data to be evaluated
+            configuration (GenAIConfiguration | AgenticAIConfiguration): Metrics configuration
+            **kwargs: Additional keyword arguments
+
+        Returns:
+            AggregateMetricResult: The computed metrics
+        """
+        data_cols = data.columns.to_list()
+
+        try:
+            validate_tool_calls(data_cols, configuration)
+            validate_input(data_cols, configuration)
+            validate_llm_as_judge(self.name, self.method,
+                                  self.llm_judge, configuration.llm_judge)
+        except ValueError as ve:
+            if kwargs.get("ignore_validation_errors"):
+                message = f"Skipping '{self.name}' computation because the validation failed. Details: {str(ve)}"
+                logger.warning(message)
+                return
+            raise ve
+
+        tool_call_provider = ToolCallMetricProvider(
+            configuration=configuration, metric=self)
+        metric_config = {
+            "general_metrics": None,
+            "function_metrics": [self.metric_mapping_name],
+            "parameter_metrics": None,
+            "transform_enabled": False
+        }
+        metric_result = await tool_call_provider.compute_metrics(
+            data, syntactic_only=False, metric_result_mapping_name="function_selection",  **metric_config)
+
+        return metric_result
+
+    def evaluate(
+        self,
+        data: pd.DataFrame | dict,
+        configuration: GenAIConfiguration | AgenticAIConfiguration,
+        **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/tool_call_syntactic_accuracy/tool_call_syntactic_accuracy_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.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.tool_call_syntactic_accuracy.tool_call_syntactic_accuracy_metric import \
+    ToolCallSyntacticAccuracyMetric
+from ibm_watsonx_gov.providers.tool_call_metric_provider import \
+    ToolCallMetricProvider
+
+
+class ToolCallSyntacticAccuracyDecorator(BaseMetricDecorator):
+    def evaluate_tool_call_syntactic_accuracy(self,
+                                              func: Optional[Callable] = None,
+                                              *,
+                                              configuration: Optional[AgenticAIConfiguration] = None,
+                                              metrics: list[GenAIMetric] = []
+                                              ) -> dict:
+        """
+        An evaluation decorator for computing tool_call_syntactic_accuracy metric on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_tool_call_syntactic_accuracy, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [ToolCallSyntacticAccuracyMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(ToolCallSyntacticAccuracyMetric,))
+
+                metric_outputs = [
+                    EvaluatorFields.TOOL_CALLS_FIELD, EvaluatorFields.OUTPUT_FIELDS]
+
+                if isinstance(configuration.tools, list) and all(callable(item) for item in configuration.tools):
+                    configuration.tools = ToolCallMetricProvider.get_tools_list_schema(
+                        configuration.tools)
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=[],
+                                                      metric_outputs=metric_outputs)
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating tool call syntactic metric on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/tool_call_syntactic_accuracy/tool_call_syntactic_accuracy_metric.py

@@ -0,0 +1,121 @@
+# ----------------------------------------------------------------------------------------------------
+# 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 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
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.providers.tool_call_metric_provider import \
+    ToolCallMetricProvider
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+from ibm_watsonx_gov.utils.validation_util import validate_tool_calls
+from pydantic import Field
+
+TOOL_CALLING_SYNTACTIC_ACCURACY = "tool_call_syntactic_accuracy"
+
+
+class ToolCallSyntacticAccuracyMetric(GenAIMetric):
+    """
+    .. deprecated:: 1.2.0
+        Use :class:`ibm_watsonx_gov.metrics.ToolCallAccuracyMetric` with syntactic method instead.
+
+    ToolCallSyntacticAccuracyMetric compute the tool call syntactic correctness 
+    by validating tool call against the schema of the list of available tools.
+
+    The ToolCallSyntacticAccuracy metric will be computed by performing the syntactic checks.
+
+    Examples:
+        1. Create ToolCallSyntacticAccuracy metric by passing the basic configuration.
+            .. code-block:: python
+
+                config = GenAIConfiguration(tools = [get_weather,fetch_stock_price])
+                evaluator = MetricsEvaluator(configuration=config)
+                df = pd.read_csv("")
+                metrics = [ToolCallSyntacticAccuracyMetric()]
+                result = evaluator.evaluate(data=df, metrics=metrics)
+
+        2. Create ToolCallSyntacticAccuracy metric by passing custom tool calls field in configuration.
+            .. code-block:: python
+
+                config = GenAIConfiguration(tools = [get_weather,fetch_stock_price],
+                                            tool_calls_field="tools_used")
+                evaluator = MetricsEvaluator(configuration=config)
+                df = pd.read_csv("")
+                metrics = [ToolCallSyntacticAccuracyMetric()]
+                result = evaluator.evaluate(data=df, metrics=metrics)
+
+        3. Create ToolCallSyntacticAccuracy metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="upper_limit", value=0.8)
+                metric = ToolCallSyntacticAccuracyMetric(threshold=threshold)
+    """
+
+    name: Annotated[Literal["tool_call_syntactic_accuracy"], Field(title="Metric Name",
+                                                                   description="The name of metric.",
+                                                                   default=TOOL_CALLING_SYNTACTIC_ACCURACY)]
+    display_name: Annotated[Literal["Tool Call Syntactic Accuracy"], Field(title="Display Name",
+                                                                           description="The tool call syntactic accuracy metric display name.",
+                                                                           default="Tool Call Syntactic Accuracy", frozen=True)]
+    tasks: Annotated[list[TaskType], Field(title="Task Type",
+                                           description="The generative task type.",
+                                           default=[TaskType.RAG])]
+    group: Annotated[MetricGroup, Field(title="Group",
+                                        description="The metric group.",
+                                        default=MetricGroup.TOOL_CALL_QUALITY, frozen=True)]
+    method: Annotated[Literal["syntactic_check"], Field(title="Computation Method",
+                                                        description="The method used to compute the metric.",
+                                                        default="syntactic_check")]
+    thresholds: Annotated[list[MetricThreshold], Field(title="Metric threshold",
+                                                       description="Value that defines the violation limit for the metric",
+                                                       default=[MetricThreshold(
+                                                           type="lower_limit", value=0.7)]
+                                                       )]
+
+    async def evaluate_async(self, data: pd.DataFrame | dict,
+                             configuration: GenAIConfiguration | AgenticAIConfiguration,
+                             **kwargs) -> AggregateMetricResult:
+        """
+        Evaluate the data for ToolCallSyntacticAccuracyMetric
+        Args:
+            data (pd.DataFrame | dict): Data to be evaluated
+            configuration (GenAIConfiguration | AgenticAIConfiguration): Metrics configuration
+
+        Returns:
+            AggregateMetricResult: The computed metrics
+        """
+        # Validate tool calls field in data and tools in configuration
+        data_cols = data.columns.to_list()
+        validate_tool_calls(data_cols, configuration)
+
+        tool_call_provider = ToolCallMetricProvider(
+            configuration=configuration, metric=self)
+
+        # Compute the metrics
+        metric_result = await tool_call_provider.compute_metrics(data)
+
+        return metric_result
+
+    def evaluate(
+        self,
+        data: pd.DataFrame | dict,
+        configuration: GenAIConfiguration | AgenticAIConfiguration,
+        **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/topic_relevance/__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/topic_relevance/topic_relevance_decorator.py

@@ -0,0 +1,57 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.topic_relevance.topic_relevance_metric import \
+    TopicRelevanceMetric
+
+
+class TopicRelevanceDecorator(BaseMetricDecorator):
+
+    def evaluate_topic_relevance(self,
+                                 func: Optional[Callable] = None,
+                                 *,
+                                 configuration: Optional[AgenticAIConfiguration] = None,
+                                 metrics: list[GenAIMetric],
+                                 ) -> dict:
+        """
+        An evaluation decorator for computing topic relevance metric on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_topic_relevance, configuration=configuration, metrics=metrics)
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(TopicRelevanceMetric))
+
+                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 topic relevance metric on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/topic_relevance/topic_relevance_metric.py

@@ -0,0 +1,106 @@
+# ----------------------------------------------------------------------------------------------------
+# 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
+
+TOPIC_RELEVANCE = "topic_relevance"
+
+
+class TopicRelevanceMetric(GenAIMetric):
+    """
+    Defines the TopicRelevance metric class.
+
+    The TopicRelevance metric evaluates how closely the input content aligns with the topic specified by the system_prompt.
+
+    Note : system_prompt is mandatory
+
+    Examples:
+        1. Create TopicRelevance metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = TopicRelevanceMetric(system_prompt="...")
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", metrics=[metric])
+
+        2. Create TopicRelevance metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="lower_limit", value=0.5)
+                metric = TopicRelevanceMetric(threshold=threshold, system_prompt="...")
+    """
+    name: Annotated[Literal["topic_relevance"],
+                    Field(title="Name",
+                          description="The topic relevance metric name.",
+                          default=TOPIC_RELEVANCE, frozen=True)]
+    display_name: Annotated[Literal["Topic Relevance"],
+                            Field(title="Display Name",
+                                  description="The topic relevance metric display name.",
+                                  default="Topic Relevance", frozen=True)]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="lower_limit", value=0.7)])]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=TaskType.values(), frozen=True)]
+    # TODO uncomment when the metric is pushed to prod
+    # group: Annotated[MetricGroup, Field(title="Group",
+    #                                     description="The metric group.",
+    #                                     default=MetricGroup.CONTENT_SAFETY, frozen=True)]
+    system_prompt: Annotated[str, Field(title="System Prompt",
+                                        description=f"The AI model system prompt which contains instructions to define its overall behavior.")]
+
+    async def evaluate_async(
+            self,
+            data: pd.DataFrame | dict,
+            configuration: GenAIConfiguration,
+            **kwargs
+    ) -> list[AggregateMetricResult]:
+        if not self.system_prompt:
+            raise AssertionError(
+                f"The system_prompt field is required but was missing from the input.")
+
+        validate_input(data.columns.to_list(), configuration)
+        # Set system_prompt as part of the detector parameters
+        kwargs["detector_params"] = {"system_prompt": self.system_prompt}
+        provider = DetectorsProvider(configuration=configuration,
+                                     metric_name=self.name,
+                                     metric_display_name=self.display_name,
+                                     metric_method=self.method,
+                                     metric_group=MetricGroup.CONTENT_SAFETY,
+                                     thresholds=self.thresholds,
+                                     **kwargs)
+        aggregated_metric_result = provider.evaluate(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/unethical_behavior/__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/unethical_behavior/unethical_behavior_decorator.py

@@ -0,0 +1,61 @@
+# ----------------------------------------------------------------------------------------------------
+# 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.unethical_behavior.unethical_behavior_metric import \
+    UnethicalBehaviorMetric
+
+
+class UnethicalBehaviorDecorator(BaseMetricDecorator):
+
+    def evaluate_unethical_behavior(self,
+                                    func: Optional[Callable] = None,
+                                    *,
+                                    configuration: Optional[AgenticAIConfiguration] = None,
+                                    metrics: list[GenAIMetric] = []
+                                    ) -> dict:
+        """
+        An evaluation decorator for computing unethical behavior on an agentic node via granite guardian.
+        """
+        if func is None:
+            return partial(self.evaluate_unethical_behavior, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [UnethicalBehaviorMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(UnethicalBehaviorMetric))
+
+                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 unethical behavior on {func.__name__},") from ex
+
+        return wrapper(func)