ibm-watsonx-orchestrate-evaluation-framework 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

wxo_agentic_evaluation/evaluation_package.py

@@ -8,6 +8,11 @@ from wxo_agentic_evaluation import __file__
 from wxo_agentic_evaluation.data_annotator import ERROR_KEYWORDS
 from wxo_agentic_evaluation.llm_matching import LLMMatcher
 from wxo_agentic_evaluation.llm_rag_eval import LLMJudge
+from wxo_agentic_evaluation.llm_safety_eval import LLMSafetyJudge
+from wxo_agentic_evaluation.metrics.llm_as_judge import (
+    AnswerDerailment,
+    AnswerUnsafeTopic,
+)
 from wxo_agentic_evaluation.metrics.metrics import (
     KeywordSemanticSearchMetric,
     KnowledgeBaseMetrics,
@@ -16,9 +21,11 @@ from wxo_agentic_evaluation.metrics.metrics import (
 )
 from wxo_agentic_evaluation.prompt.template_render import (
     AnswerRelevancyTemplateRenderer,
+    DerailmentTemplateRenderer,
     FaithfulnessTemplateRenderer,
     KeywordMatchingTemplateRenderer,
     SemanticMatchingTemplateRenderer,
+    UnsafeTopicTemplateRenderer,
 )
 from wxo_agentic_evaluation.resource_map import ResourceMap
 from wxo_agentic_evaluation.service_provider import get_provider
@@ -49,6 +56,14 @@ RESERVED_KEYWORD_FOR_GROUND_TRUTH_ARGS = os.getenv(
     "RESERVED_KEYWORD_FOR_GROUND_TRUTH_ARGS", "<IGNORE>"
 )
 
+DERAILMENT_PROMPT_PATH = os.path.join(
+    root_dir, "prompt", "derailment_prompt.jinja2"
+)
+
+UNSAFE_TOPIC_PROMPT_PATH = os.path.join(
+    root_dir, "prompt", "unsafe_topic_prompt.jinja2"
+)
+
 """
 - hyphens are not allowed in python function names, so it is safe to use as a dummy function name
 - purpose behind `DUMMY_GRAPH_NODE_NAME` is to append
@@ -68,16 +83,26 @@ class EvaluationPackage:
         resource_map: ResourceMap = None,
         is_attack_evaluation: bool = False,
     ):
-        self.tool_dictionary = {
-            goal_detail.name: goal_detail
-            for goal_detail in ground_truth.goal_details
-            if goal_detail.type == ContentType.tool_call
-        }
-        self.text_list = [
-            goal_detail
-            for goal_detail in ground_truth.goal_details
-            if goal_detail.type == ContentType.text
-        ]
+        self.tool_dictionary = (
+            {
+                goal_detail.name: goal_detail
+                for goal_detail in ground_truth.goal_details
+                if goal_detail.type == ContentType.tool_call
+            }
+            if ground_truth.goal_details
+            else {}
+        )
+
+        self.text_list = (
+            [
+                goal_detail
+                for goal_detail in ground_truth.goal_details
+                if goal_detail.type == ContentType.text
+            ]
+            if ground_truth.goal_details
+            else []
+        )
+
         self.messages = messages
         self.conversational_search_data = conversational_search_data
         self.is_attack_evaluation = is_attack_evaluation
@@ -118,6 +143,22 @@ class EvaluationPackage:
                 ANSWER_RELEVANCY_PROMPT_PATH
             ),
         )
+        self.safety_llm_as_a_judge = LLMSafetyJudge(
+            llm_client=get_provider(
+                model_id="meta-llama/llama-3-405b-instruct",
+                params={
+                    "min_new_tokens": 0,
+                    "decoding_method": "greedy",
+                    "max_new_tokens": 4096,
+                },
+            ),
+            answer_derailment=DerailmentTemplateRenderer(
+                DERAILMENT_PROMPT_PATH
+            ),
+            answer_unsafe_topic=UnsafeTopicTemplateRenderer(
+                UNSAFE_TOPIC_PROMPT_PATH
+            ),
+        )
 
     @staticmethod
     def find_ground_node(graph, start_node):
@@ -238,6 +279,29 @@ class EvaluationPackage:
                     f"[green][SUCCESS] Text message matched: Summary - {keyword_semantic_match.message}[/green]"
                 )
 
+    @staticmethod
+    def normalize_args(data):
+        if isinstance(data, dict):
+            # normalize keys (case-sensitive) and values
+            return {
+                str(k): EvaluationPackage.normalize_args(v)
+                for k, v in data.items()
+            }
+
+        elif isinstance(data, list):
+            normalized_list = [
+                EvaluationPackage.normalize_args(v) for v in data
+            ]
+            return sorted(
+                normalized_list, key=lambda v: json.dumps(v, sort_keys=True)
+            )
+
+        else:
+            # don’t lowercase reserved keyword
+            if str(data) == RESERVED_KEYWORD_FOR_GROUND_TRUTH_ARGS:
+                return str(data)
+            return str(data).lower()
+
     @staticmethod
     def _check_if_args_match_with_ignore(
         actual_args: dict[str, str], expected_args: dict[str, str]
@@ -257,8 +321,10 @@ class EvaluationPackage:
 
         for key in actual_args:
             if (
-                actual_args[key] != expected_args[key]
-                and expected_args[key] != RESERVED_KEYWORD_FOR_GROUND_TRUTH_ARGS
+                EvaluationPackage.normalize_args(actual_args[key])
+                != EvaluationPackage.normalize_args(expected_args[key])
+                and EvaluationPackage.normalize_args(expected_args[key])
+                != RESERVED_KEYWORD_FOR_GROUND_TRUTH_ARGS
             ):
                 return False
 
@@ -326,7 +392,12 @@ class EvaluationPackage:
                     for goal_detail in matching_goal_details:
                         # {"IGNORE": None} is set in red teaming attack ground truth to ignore parameter matching
                         if goal_detail.args == {"IGNORE": None} or (
-                            msg_tool_call["args"] == goal_detail.args
+                            EvaluationPackage.normalize_args(
+                                msg_tool_call["args"]
+                            )
+                            == EvaluationPackage.normalize_args(
+                                goal_detail.args
+                            )
                             or self._check_if_args_match_with_ignore(
                                 msg_tool_call["args"], goal_detail.args
                             )
@@ -591,6 +662,51 @@ class EvaluationPackage:
 
         return metrics
 
+    def evaluate_derailment(
+        self, instructions: str = None
+    ) -> List[AnswerDerailment]:
+        derailments = []
+        last_user_message = None
+        for message in self.messages:
+            if message.role == "user" and message.type == ContentType.text:
+                last_user_message = message
+            if message.role == "assistant" and message.type == ContentType.text:
+                derailment = (
+                    self.safety_llm_as_a_judge.judge_derailment_in_answer(
+                        question=last_user_message.content,
+                        instructions=instructions if instructions else "N/A",
+                        answer=message.content,
+                    )
+                )
+                derailments.append(derailment)
+                if derailment.in_scope == "no":
+                    return (
+                        derailments  # short-circuit if any derailment is found
+                    )
+        return derailments
+
+    def evaluate_unsafe_topics(
+        self, instructions: str = None
+    ) -> List[AnswerUnsafeTopic]:
+        unsafe_topics = []
+        last_user_message = None
+        for message in self.messages:
+            if message.role == "user" and message.type == ContentType.text:
+                last_user_message = message
+            if message.role == "assistant" and message.type == ContentType.text:
+                unsafe_topic = (
+                    self.safety_llm_as_a_judge.judge_unsafe_topic_in_answer(
+                        question=last_user_message.content,
+                        instructions=instructions if instructions else "N/A",
+                        answer=message.content,
+                    )
+                )
+                unsafe_topics.append(unsafe_topic)
+                if unsafe_topic.is_safe == "no":
+                    return unsafe_topics  # short-circuit if any unsafe topic is found
+
+        return unsafe_topics
+
 
 if __name__ == "__main__":
 

wxo_agentic_evaluation/external_agent/external_validate.py

@@ -41,15 +41,15 @@ class ExternalAgentValidation:
         data = b""
         for chunk in resp:
             for line in chunk.splitlines(True):
-                if line.startswith(b"data:"):
-                    line = line.replace(b"data:", b"")
-                if line.strip() == b"[DONE]":
-                    return
+                if line.startswith(b"event:"):
+                    continue
                 data += line
                 if data.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")):
                     # NOTE: edge case, "data" can be sent in two different chunks
                     if data.startswith(b"data:"):
                         data = data.replace(b"data:", b"")
+                    if data.strip() == b"[DONE]":
+                        return
                     yield data
                     data = b""
         if data:
@@ -74,7 +74,7 @@ class ExternalAgentValidation:
         payload = {"stream": True}
         payload["messages"] = messages
         resp = requests.post(
-            url=self.service_url, headers=self.header, json=payload
+            url=self.service_url, headers=self.header, json=payload,
         )
         success, logged_events = self._validate_streaming_response(resp)
 

wxo_agentic_evaluation/external_agent/types.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Literal, Mapping, Union
+from typing import Any, List, Literal, Mapping, Union, Optional
 
 from pydantic import BaseModel
 
@@ -46,7 +46,7 @@ class ThreadRunStepDeltaChoice(BaseModel):
 class BaseEventData(BaseModel):
     id: str
     object: str
-    thread_id: str
+    thread_id: Optional[str] = None
     model: str | None = None
     created: int | None = None
 
@@ -62,13 +62,7 @@ class ThreadRunStepDeltaData(BaseEventData):
 
 
 class UniversalData(BaseEventData):
-    object: Union[
-        Literal["thread.message.delta"],
-        Literal["thread.run.step.delta"],
-        Literal["thread.run.step.created"],
-        Literal["thread.run.step.completed"],
-    ]
-    choices: List[ThreadMessageDeltaChoice]
+    object: Optional[str]
     choices: List[Union[ThreadMessageDeltaChoice, dict]]
 
 

wxo_agentic_evaluation/inference_backend.py

@@ -14,7 +14,10 @@ from urllib3.exceptions import InsecureRequestWarning
 
 from wxo_agentic_evaluation.arg_configs import TestConfig
 from wxo_agentic_evaluation.llm_user import LLMUser
-from wxo_agentic_evaluation.service_instance import get_env_settings, tenant_setup
+from wxo_agentic_evaluation.service_instance import (
+    get_env_settings,
+    tenant_setup,
+)
 from wxo_agentic_evaluation.service_provider.watsonx_provider import (
     WatsonXProvider,
 )
@@ -80,7 +83,9 @@ class CallTracker(BaseModel):
 
 
 class WXOClient:
-    def __init__(self, service_url, api_key, env: Optional[Dict[str, Any]] = None):
+    def __init__(
+        self, service_url, api_key, env: Optional[Dict[str, Any]] = None
+    ):
         self.service_url = service_url
         self.api_key = api_key
 
@@ -88,11 +93,22 @@ class WXOClient:
         if ov and ov.strip().lower() in ("true", "false"):
             self._verify_ssl = ov.strip().lower() == "true"
         else:
-            v, bs = (env.get("verify") if env else None), (env.get("bypass_ssl") if env else None)
-            self._verify_ssl = False if (
-                (bs is True) or (isinstance(bs, str) and bs.strip().lower() == "true") or
-                (v is None) or (isinstance(v, str) and v.strip().lower() in {"none", "null"})
-            ) else (v if isinstance(v, bool) else True)
+            v, bs = (env.get("verify") if env else None), (
+                env.get("bypass_ssl") if env else None
+            )
+            self._verify_ssl = (
+                False
+                if (
+                    (bs is True)
+                    or (isinstance(bs, str) and bs.strip().lower() == "true")
+                    or (v is None)
+                    or (
+                        isinstance(v, str)
+                        and v.strip().lower() in {"none", "null"}
+                    )
+                )
+                else (v if isinstance(v, bool) else True)
+            )
 
         if not self._verify_ssl:
             urllib3.disable_warnings(InsecureRequestWarning)
@@ -779,11 +795,14 @@ def get_wxo_client(
     service_url = service_url or resolved_url
 
     if not (service_url and str(service_url).strip()):
-        raise ValueError(f"service_url not provided and not found in config for tenant '{tenant_name}'")
+        raise ValueError(
+            f"service_url not provided and not found in config for tenant '{tenant_name}'"
+        )
 
     wxo_client = WXOClient(service_url=service_url, api_key=token, env=env)
     return wxo_client
 
+
 if __name__ == "__main__":
     wai_client = WatsonXProvider(model_id="meta-llama/llama-3-3-70b-instruct")
     auth_config_path = (

wxo_agentic_evaluation/llm_safety_eval.py

@@ -0,0 +1,64 @@
+import json
+import re
+
+from wxo_agentic_evaluation.metrics.llm_as_judge import (
+    AnswerDerailment,
+    AnswerUnsafeTopic,
+)
+from wxo_agentic_evaluation.prompt.template_render import (
+    DerailmentTemplateRenderer,
+    UnsafeTopicTemplateRenderer,
+)
+from wxo_agentic_evaluation.service_provider.watsonx_provider import Provider
+
+
+class LLMSafetyJudge:
+    def __init__(
+        self,
+        llm_client: Provider,
+        answer_derailment: DerailmentTemplateRenderer,
+        answer_unsafe_topic: UnsafeTopicTemplateRenderer,
+    ):
+        self.llm_client = llm_client
+        self.answer_derailment_template = answer_derailment
+        self.answer_unsafe_topic_template = answer_unsafe_topic
+
+    def judge_derailment_in_answer(
+        self, question: str, instructions: str, answer: str
+    ) -> AnswerDerailment:
+        prompt = self.answer_derailment_template.render(
+            question=question, instructions=instructions, answer=answer
+        )
+        output = self.llm_client.query(prompt)
+        result = output.strip().lower()
+        try:
+            json_str = re.search(r"\{.*\}", result, re.DOTALL).group(0)
+            thejson = json.loads(json_str)
+            answer_derailment = AnswerDerailment.model_validate(thejson)
+        except Exception:
+            answer_derailment = AnswerDerailment(
+                in_scope="not sure", statement=answer, reason=result
+            )
+        return answer_derailment
+
+    def judge_unsafe_topic_in_answer(
+        self, question: str, instructions: str, answer: str
+    ) -> AnswerUnsafeTopic:
+        """
+        Use LLM to judge if the answer contains unsafe topics.
+        """
+        prompt = self.answer_unsafe_topic_template.render(
+            question=question, instructions=instructions, answer=answer
+        )
+        output = self.llm_client.query(prompt)
+        result = output.strip().lower()
+        try:
+            json_str = re.search(r"\{.*\}", result, re.DOTALL).group(0)
+            thejson = json.loads(json_str)
+            answer_unsafe = AnswerUnsafeTopic.model_validate(thejson)
+        except Exception:
+            answer_unsafe = AnswerUnsafeTopic(
+                is_safe="not sure", statement=answer, reason=result
+            )
+
+        return answer_unsafe