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

ibm_watsonx_gov/tools/onboarding/create/wikipedia_search_tool.json

@@ -0,0 +1,53 @@
+{
+    "display_name": "Wikipedia Search",
+    "tool_name": "wikipedia_search_tool",
+    "service_provider_type": "IBM",
+    "description": "Search Wikipedia and return results for given query",
+    "inventory_id": "<attribute_value>",
+    "reusable": "true",
+    "category": ["Search"],
+    "framework": ["langchain","langgraph"],
+    "code": {
+        "source_code_base64": "",
+        "run_time_details": {
+            "engine": "Python >=3.11"
+        }
+    },
+    "config":{
+            "description": "Configuration schema for OOTB search tools",
+            "properties": {
+              "top_k_results": {
+                "default": 3,
+                "description": "Number of search results to retrieve",
+                "title": "Top K Results",
+                "type": "integer"
+              }
+            },
+            "title": "SearchToolConfig",
+            "type": "object"
+    },
+    "schema":{
+        "properties": {
+          "query": {
+            "description": "Search the input from the given search tool",
+            "title": "Query",
+            "type": "string"
+          },
+          "top_k_results": {
+            "default": 3,
+            "description": "Number of search results to retrieve",
+            "title": "Top K Results",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "query"
+        ],
+        "title": "SearchToolInput",
+        "type": "object"
+    },
+  "dependencies": {
+        "remote_services":[],
+        "run_time_packages":["wikipedia"]
+  }
+}

ibm_watsonx_gov/tools/onboarding/delete/delete_tools.json

@@ -0,0 +1,4 @@
+{
+  "tool_names": [
+  ]
+}

ibm_watsonx_gov/tools/onboarding/update/google_search_tool.json

@@ -0,0 +1,38 @@
+{
+  "tool_name": "google_search_tool",
+  "version": "1.1.0",
+  "patch_tool": [
+    {
+      "op": "replace",
+      "path": "/config",
+      "value": {
+        "description": "Configuration schema for OOTB search tools",
+        "properties": {
+          "top_k_results": {
+            "default": 3,
+            "description": "Number of search results to retrieve",
+            "title": "Top K Results",
+            "type": "integer"
+          },
+          "serpapi_key": {
+            "description": "API key used to authenticate requests to SerpAPI. You can generate your API key from https://serpapi.com/manage-api-key.",
+            "title": "SerpAPI Key",
+            "type": "string"
+          }
+        },
+        "title": "SearchToolConfig",
+        "type": "object",
+        "required": [
+        "serpapi_key"
+      ]
+      }
+    },
+    {
+      "op": "replace",
+      "path": "/dependencies/run_time_packages",
+      "value": [
+        "google-search-results"
+      ]
+    }
+  ]
+}

ibm_watsonx_gov/tools/ootb/__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/tools/ootb/detectors/__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/tools/ootb/detectors/hap_detector_tool.py

@@ -0,0 +1,109 @@
+# ----------------------------------------------------------------------------------------------------
+# 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  ibm_watsonx_gov.tools.clients.detector_client as dc
+
+from typing import Annotated, List, Optional, Type
+from langchain.callbacks.manager import CallbackManagerForToolRun
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+
+
+class HAPInput(BaseModel):
+    """
+        Model that can be used for setting input args for HAPDetectorTool
+    """
+    input: Annotated[str,
+                     Field(..., description="Detect HAP for the given input")]
+    threshold: Annotated[Optional[float], Field(
+        0.8, description="Threshold for hap detection in the input, values range from 0.0 to 1.0")]
+
+
+class HAPConfig(BaseModel):
+    """
+        Model that can be used for setting threshold for HAPDetectorTool
+    """
+    threshold: Annotated[Optional[float], Field(
+        0.8, description="Threshold for hap detection in the input, values range from 0.0 to 1.0")]
+
+
+class HAPDetectorTool(BaseTool):
+    """
+    Tool to detect Hate, Abuse and Profanity content in input string
+
+    Examples:
+        Basic usage
+            .. code-block:: python
+
+                hap_detector_tool = HAPDetectorTool()
+                hap_detector_tool.invoke({"input":"<USER_INPUT>"})
+    """
+    name: str = "hap_detector"
+    description: str = "Tool to detect Hate, Abuse and Profanity content in the input string"
+    args_schema: Type[BaseModel] = HAPInput
+
+    _url: any = PrivateAttr()
+    _threshold: any = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        config = HAPConfig(**kwargs)
+        self._threshold = config.threshold
+        self._url = dc.DETECTIONS_URL.format(dc.get_base_url())
+        self._base_payload = dc.get_base_payload(dc.HAP,detector_params= {
+                                                                            "threshold": 0.0
+                                                                        })
+
+    # Define HAP Tool
+    def _run(self,
+             input: str,
+             run_manager: Optional[CallbackManagerForToolRun] = None,
+             **kwargs) -> List[str]:
+        """
+        Detects Hate, Abuse and Profanity content in the input string
+
+        Sample Response:
+            {
+              'detections': [{'start': 0,
+                'end': 46,
+                'text': '<USER_INPUT>',
+                'detection_type': 'hap',
+                'detection': 'has_HAP',
+                'score': 0.9495730400085448,
+                }],
+              'is_hap_detected': True
+            }
+        """
+
+        threshold = kwargs.get("threshold",self._threshold)
+        # By default threshold is 0.0 and score is compared with the default/user provided threshold
+       
+        payload = dc.get_payload(self._base_payload,detector_payload={
+                                                                        "input":input
+                                                                     })
+        response = dc.call_detections(self._url, payload)
+        
+
+        #Add boolean to response
+        response["is_hap_detected"] = False
+        for detection in response.get("detections"):
+            if detection.get("score") > threshold:
+                response["is_hap_detected"] = True
+                break
+
+        return response
+    
+    async def _arun(self,
+                    input: str,
+                    run_manager: Optional[CallbackManagerForToolRun] = None,
+                    **kwargs) -> List[str]:
+        
+        return self._run(input , kwargs)

ibm_watsonx_gov/tools/ootb/detectors/jailbreak_detector_tool.py

@@ -0,0 +1,104 @@
+# ----------------------------------------------------------------------------------------------------
+# 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 json
+
+import  ibm_watsonx_gov.tools.clients.detector_client as dc
+
+from typing import Annotated, List, Optional, Type
+
+from langchain.callbacks.manager import CallbackManagerForToolRun
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class JailBreakInput(BaseModel):
+    """
+        Model that can be used for setting input args for JailBreakDetectorTool
+    """
+    input: Annotated[str,
+                     Field(..., description="Detect JailBreak for the given input")]
+    threshold: Annotated[Optional[float], Field(
+        0.8, description="Threshold for detecting jailbreak in the input, values range from 0.0 to 1.0")]
+
+
+class JailBreakConfig(BaseModel):
+    """
+        Model that can be used for setting threshold for JailBreakDetectorTool
+    """
+    threshold: Annotated[Optional[float], Field(
+        0.8, description="Threshold for detecting jailbreak in the input, values range from 0.0 to 1.0")]
+
+
+class JailBreakDetectorTool(BaseTool):
+    """
+    Tool to detect 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.
+
+    Examples:
+        Basic usage
+            .. code-block:: python
+
+                jailbreak_detector_tool = JailBreakDetectorTool()
+                jailbreak_detector_tool.invoke({"input":"<USER_INPUT>"})
+    """
+
+    name: str = "jailbreak_detector"
+    description: str = """Tool that detects 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."""
+    args_schema: Type[BaseModel] = JailBreakInput
+
+    _url: any = PrivateAttr()
+    _threshold: any = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        config = JailBreakConfig(**kwargs)
+        self._threshold = config.threshold
+        self._url = dc.DETECTIONS_URL.format(dc.get_base_url())
+        self._base_payload = dc.get_base_payload(dc.GRANITE_GUADIAN,detector_params= {
+                                                                            "risk_name": "jailbreak",
+                                                                            "threshold": 0.0
+                                                                        })
+
+    # Define JailBreak Tool
+    def _run(self,
+             input: str,
+             run_manager: Optional[CallbackManagerForToolRun] = None,
+             **kwargs) -> List[str]:
+        """
+         Sample Response:
+            {'detections': [{'start': 0,
+                            'end': 26,
+                            'text': '<USER_INPUT>',
+                            'detection_type': 'risk',
+                            'detection': 'Yes',
+                            'score': 0.9688562154769896}],
+             'is_jailbreak_detected': True}
+        """
+        threshold = kwargs.get("threshold",self._threshold)
+        payload = dc.get_payload(self._base_payload,detector_payload={
+                                                                        "input":input
+                                                                     })
+        response = dc.call_detections(self._url, payload)
+
+        if response.get("detections")[0].get("score") > threshold:
+            response["is_jailbreak_detected"] = True
+        else:
+            response["is_jailbreak_detected"] = False
+        return response
+    
+    async def _arun(self,
+                    input: str,
+                    run_manager: Optional[CallbackManagerForToolRun] = None,
+                    **kwargs) -> List[str]:
+        
+        return self._run(input , kwargs)

ibm_watsonx_gov/tools/ootb/detectors/pii_detector_tool.py

@@ -0,0 +1,83 @@
+# ----------------------------------------------------------------------------------------------------
+# 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  ibm_watsonx_gov.tools.clients.detector_client as dc
+
+from typing import Annotated, List, Optional, Type
+from langchain.callbacks.manager import CallbackManagerForToolRun
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class PIIInput(BaseModel):
+    """
+        Model that can be used for setting input args for PIIDetectorTool
+    """
+    input: Annotated[str,
+                     Field(..., description="Detect PII for the given input")]
+
+
+class PIIDetectorTool(BaseTool):
+    """
+    Tool to detect PII content in input string
+
+    Examples:
+        Basic usage
+            .. code-block:: python
+
+                pii_detector_tool = PIIDetectorTool()
+                pii_detector_tool.invoke({"input":"<USER_INPUT>"})
+    """
+    name: str = "pii_detector"
+    description: str = "Tool that detects Personally Identifiable Information(PII) information in the input string."
+    args_schema: Type[BaseModel] = PIIInput
+    _url: any = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._url = dc.DETECTIONS_URL.format(dc.get_base_url())
+        self._base_payload = dc.get_base_payload(dc.PII)
+
+    # Define PII Tool
+    def _run(self,
+             input: str,
+             run_manager: Optional[CallbackManagerForToolRun] = None,
+             **kwargs) -> List[str]:
+        
+        """
+        Sample Response:
+            {'detections': [{'start': 15,
+                            'end': 30,
+                            'text': 'johndoe@abc.com',
+                            'detection_type': 'pii',
+                            'detection': 'EmailAddress',
+                            'score': 0.8}],
+            'is_pii_detected': True}
+        """
+       
+        payload = dc.get_payload(self._base_payload,detector_payload={
+                                                                        "input":input
+                                                                     })
+        response = dc.call_detections(self._url, payload)
+        
+
+        if response.get("detections") == []:
+            # No PII information detected
+            response["is_pii_detected"] = False
+        else:
+            response["is_pii_detected"] = True
+
+        return response
+    
+    async def _arun(self,
+                    input: str,
+                    run_manager: Optional[CallbackManagerForToolRun] = None,
+                    **kwargs) -> List[str]:
+        
+        return self._run(input , kwargs)

ibm_watsonx_gov/tools/ootb/detectors/prompt_safety_risk_detector_tool.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.
+# ----------------------------------------------------------------------------------------------------
+
+import json
+import ibm_watsonx_gov.tools.clients.detector_client as dc
+from typing import Annotated, List, Optional, Type
+from langchain.callbacks.manager import CallbackManagerForToolRun
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class PromptSafetyRiskInput(BaseModel):
+    """
+        Model that can be used for setting input args for PromptSafetyRiskTool
+    """
+    input: Annotated[str,
+                     Field(..., description="Detect PromptSafetyRisk for the given input")]
+    threshold: Annotated[Optional[float], Field(
+        default=0.8, description="Threshold for prompt safety risk detection in the input, values range from 0.0 to 1.0")]
+    system_prompt: Annotated[str,
+                             Field(..., description="System prompt to configure the chatbot's behavior.")]
+    enable_two_level_detection: Annotated[Optional[bool], Field(
+        default=True, description="Enable or disable two level detection")]
+
+
+class PromptSafetyRiskConfig(BaseModel):
+    """
+        Model that can be used for setting threshold for PromptSafetyRiskTool
+    """
+    threshold: Annotated[Optional[float], Field(
+        default=0.8, description="Threshold for prompt safety risk detection in the input, values range from 0.0 to 1.0")]
+    enable_two_level_detection: Annotated[Optional[bool], Field(
+        default=False, description="Enable or disable two level detection")]
+
+
+class PromptSafetyRiskDetectorTool(BaseTool):
+    """
+    Prompt Safety Risk tool measures the intent of jailbreak and/or prompt injection in the input sent to the LLM.
+
+    Examples:
+        Basic usage
+            .. code-block:: python
+
+                prompt_safety_detector_tool = PromptSafetyRiskTool()
+                prompt_safety_detector_tool.invoke({"input":"<USER_INPUT>", "system_prompt":"<SYSTEM_PROMPT>"})
+    """
+
+    name: str = "prompt_safety_risk_detector"
+    description: str = "Tool that detects off topic and prompt injection attempts in user input"
+    args_schema: Type[BaseModel] = PromptSafetyRiskInput
+
+    _threshold: any = PrivateAttr()
+    _system_prompt: any = PrivateAttr()
+    _url: any = PrivateAttr()
+    _enable_two_level_detection: any = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        config = PromptSafetyRiskConfig(**kwargs)
+        self._threshold = config.threshold
+        self._enable_two_level_detection = config.enable_two_level_detection
+        self._url = dc.DETECTIONS_URL.format(dc.get_base_url())
+
+    def _run(self,
+             input: str,
+             system_prompt:str,
+             run_manager: Optional[CallbackManagerForToolRun] = None,
+             **kwargs) -> List[str]:
+        
+        """
+        Sample Response:
+            {'detections': [{'start': 0,
+                            'end': 36,
+                            'text': '<USER_INPUT>',
+                            'detection_type': 'topic_relevance',
+                            'detection': 'off-topic',
+                            'score': 0.9422797560691832}],
+            'is_prompt_safety_risk_detected': True}
+        """
+        
+        threshold = threshold = kwargs.get("threshold",self._threshold)
+        enable_two_level_detection = kwargs.get("enable_two_level_detection",self._enable_two_level_detection)
+
+        # Default or user provided threshold and enable_two_level_detection is passed to the endpoint
+        detector_params = {
+            "system_prompt": system_prompt,
+            "enable_two_level_detection": enable_two_level_detection,
+            "threshold": 0.0
+        }
+
+        base_payload = dc.get_base_payload(dc.PROMPT_SAFETY_RISK,detector_params)
+
+        # payload = get_payload(
+        #     self.detector_name, input, detector_params=detector_params)
+        payload = dc.get_payload(base_payload,detector_payload={
+                                                                        "input":input
+                                                                     })
+        response = dc.call_detections(self._url, payload)
+        
+
+        if len(response.get("detections")) > 0 and response.get("detections")[0].get("score") > threshold:
+            response["is_prompt_safety_risk_detected"] = True
+        else:
+            response["is_prompt_safety_risk_detected"] = False
+        return response

ibm_watsonx_gov/tools/ootb/detectors/topic_relevance_detector_tool.py

@@ -0,0 +1,101 @@
+# ----------------------------------------------------------------------------------------------------
+# 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 json
+import  ibm_watsonx_gov.tools.clients.detector_client as dc
+
+from typing import Annotated, List, Optional, Type
+
+from langchain.callbacks.manager import CallbackManagerForToolRun
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field, PrivateAttr
+
+
+class TopicRelevanceDetectorInput(BaseModel):
+    """
+        Model that can be used for setting input args for TopicRelevanceDetectorTool
+    """
+    input: Annotated[str,
+                     Field(..., description="Detect topic relevance for the given input")]
+    threshold: Annotated[Optional[float], Field(
+        default=0.8, description="Threshold for off-topic detection in the input, values range from 0.0 to 1.0")]
+    system_prompt: Annotated[str,
+                             Field(..., description="System prompt to configure the chatbot's behavior.")]
+
+
+class TopicRelevanceDetectorConfig(BaseModel):
+    """
+        Model that can be used for setting threshold for TopicRelevanceDetectorTool
+    """
+    threshold: Annotated[Optional[float], Field(
+        default=0.8, description="Threshold for off-topic detection in the input, values range from 0.0 to 1.0")]
+
+
+class TopicRelevanceDetectorTool(BaseTool):
+    """
+    Tool that analyzes whether the user input is relevant to the topic defined in the system prompt and measures the degree of alignment.
+
+    Examples:
+        Basic usage
+            .. code-block:: python
+
+                topic_relevance_detector = TopicRelevanceDetectorTool()
+                topic_relevance_detector.invoke({"input":"<USER_INPUT>", "system_prompt":"<SYSTEM_PROMPT>"})
+    """
+
+    name: str = "topic_relevance_detector"
+    description: str = "Tool that analyzes whether the user input is relevant to the topic defined in the system prompt and measures the degree of alignment."
+    args_schema: Type[BaseModel] = TopicRelevanceDetectorInput
+
+    _threshold: any = PrivateAttr()
+    _system_prompt: any = PrivateAttr()
+    _url: any = PrivateAttr()
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        config = TopicRelevanceDetectorConfig(**kwargs)
+        self._threshold = config.threshold
+        self._url = dc.DETECTIONS_URL.format(dc.get_base_url())
+
+    def _run(self,
+             input: str,
+             system_prompt,
+             run_manager: Optional[CallbackManagerForToolRun] = None,
+             **kwargs) -> List[str]:
+        """
+        Sample Response:
+            {'detections': [{'start': 0,
+                            'end': 35,
+                            'text': '<USER_INPUT>',
+                            'detection_type': 'topic_relevance',
+                            'detection': 'off-topic',
+                            'score': 0.847662091255188}],
+            'is_topic_relevant': False}
+        """
+
+        threshold = kwargs.get("threshold",self._threshold)
+        # By default threshold is 0.0 and score is compared with the default/user provided threshold
+        detector_params = {
+            "system_prompt": system_prompt,
+            "threshold": 0.0
+        }
+
+        base_payload = dc.get_base_payload(dc.TOPIC_RELEVANCE,detector_params)
+        payload = dc.get_payload(base_payload,detector_payload={
+                                                                        "input":input
+                                                                     })
+        response = dc.call_detections(self._url, payload)
+        
+        
+        #Propogate boolean values
+        if len(response.get("detections")) > 0 and response.get("detections")[0].get("score") > threshold:
+            response["is_topic_relevant"] = False
+        else:
+            response["is_topic_relevant"] = True
+        return response

ibm_watsonx_gov/tools/ootb/rag/__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.
+# ----------------------------------------------------------------------------------------------------