pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/integration/lab/reasoning_strategies/test_get_reasoning_strategy.py

@@ -0,0 +1,70 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import ReasoningStrategy
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabGetReasoningStrategyIntegration(TestCase):   
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.strategy_id = "0a3b039e-25bd-4cf9-ad67-7af2b654874b"
+        self.strategy_name = "Chain of Thought"
+
+    def __get_reasoning_strategy(self, strategy_id = None, strategy_name = None):
+        return self.ai_lab_manager.get_reasoning_strategy(
+            reasoning_strategy_id= strategy_id if strategy_id is not None else self.strategy_id,
+            reasoning_strategy_name=strategy_name if strategy_name is not None else self.strategy_name
+        )
+
+    def test_get_reasoning_strategy_by_id(self):
+        strategy = self.__get_reasoning_strategy(strategy_name="")
+
+        self.assertIsInstance(strategy, ReasoningStrategy, "Expected a reasoning strategy")
+        self.assertEqual(strategy.id, self.strategy_id, "Expected reasoning strategy ID to match")
+
+
+    def test_get_reasoning_strategy_by_name(self):
+        strategy = self.__get_reasoning_strategy(strategy_id="")
+        
+        self.assertIsInstance(strategy, ReasoningStrategy, "Expected a reasoning strategy")
+        self.assertEqual(
+            strategy.name, 
+            self.strategy_name,
+            "Expected reasoning strategy name to match"
+        )
+
+
+    def test_get_reasoning_strategy_no_id_or_name(self):
+        with self.assertRaises(Exception) as context:
+            self.__get_reasoning_strategy(strategy_id="", strategy_name="")
+
+        self.assertIn(
+            "Either reasoning_strategy_id or reasoning_strategy_name must be provided.",
+            str(context.exception),
+            "Expected error message for missing id and name"
+        )
+
+
+    def test_get_reasoning_strategy_invalid_id(self):
+        invalid_id = "invalid-id-1234"
+        with self.assertRaises(APIError) as context:
+            self.__get_reasoning_strategy(strategy_id=invalid_id)
+        self.assertIn(
+            f"Reasoning-Strategy not found (idOrName={invalid_id}",
+            str(context.exception),
+            "Expected an error for invalid reasoning strategy id"
+        )
+
+
+    def test_get_reasoning_strategy_invalid_name(self):
+        invalid_name = "Nonexistent Strategy"
+        with self.assertRaises(APIError) as context:
+            self.__get_reasoning_strategy(strategy_id="", strategy_name=invalid_name)
+
+        self.assertIn(
+            f"Reasoning-Strategy not found (idOrName={invalid_name})",
+            str(context.exception),
+            "Expected an error for invalid reasoning strategy name"
+        )

pygeai/tests/integration/lab/reasoning_strategies/test_list_reasoning_strategies.py

@@ -0,0 +1,93 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, ReasoningStrategyList
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListReasoningStrategiesIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.filter_settings = FilterSettings(
+            name="",
+            start=0,
+            count=100,
+            allow_external=True,
+            access_scope="public"
+        )
+
+    
+    def __list_reasoning_strategies(self, filter_settings: FilterSettings = None):
+        filter_settings = filter_settings if filter_settings is not None else self.filter_settings
+        return self.ai_lab_manager.list_reasoning_strategies(filter_settings=filter_settings)
+    
+    
+    def test_public_list_reasoning_strategies(self):
+        result = self.__list_reasoning_strategies()
+
+        self.assertIsInstance(result, ReasoningStrategyList, "Expected a list of reasoning strategies")
+        for strategy in result.strategies:
+            self.assertTrue(
+                strategy.access_scope == "public",
+                "Expected all reasoning strategies to be public"
+            )
+
+
+    def test_private_list_reasoning_strategies(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "private"
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, ReasoningStrategyList, "Expected a list of reasoning strategies")
+        for strategy in result.strategies:
+            self.assertTrue(
+                strategy.access_scope == "private",
+                "Expected all reasoning strategies to be private"
+            )
+
+
+    def test_list_reasoning_strategies_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertEqual(
+            len(result), 2,
+            "Expected list of reasoning strategies returned to be 2"
+        )
+
+
+    def test_list_reasoning_strategies_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 500
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertLessEqual(
+            len(result), 500,
+            "Expected list of reasoning strategies returned to be 500 or less"
+        )
+
+
+    def test_list_reasoning_strategies_name_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.name = "Chain of Thought"
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+
+        for strategy in result.strategies:
+            self.assertIn(
+                "Chain of Thought",
+                strategy.name,
+                "Expected reasoning strategy name to contain filter value"
+            )
+
+   
+    def test_list_reasoning_strategies_invalid_scope(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "project"
+
+        with self.assertRaises(ValueError) as exception:
+            self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertIn(
+            "Access scope must be either 'public' or 'private'.",
+            str(exception.exception),
+            "The expected error about invalid scope was not returned"
+        )

pygeai/tests/integration/lab/reasoning_strategies/test_update_reasoning_strategy.py

@@ -0,0 +1,149 @@
+from unittest import TestCase
+import unittest
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import LocalizedDescription, ReasoningStrategy
+from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIError, APIResponseError
+
+class TestAILabCreateReasoningStrategyIntegration(TestCase):    
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+        self.strategy_to_update = self.__load_strategy()
+
+    
+    def __load_strategy(self):
+        self.random_str = str(uuid.uuid4())
+        return ReasoningStrategy(
+            id="323f5f94-5a3d-4717-89f3-3554a33c093f",
+            name=f"UpdatedStrategy_{self.random_str}",
+            system_prompt=f"Let's think step by step. {self.random_str}",
+            access_scope="private",
+            type="addendum",
+            localized_descriptions=[
+                LocalizedDescription(language="spanish", description=f"RSName spanish description {self.random_str}"),
+                LocalizedDescription(language="english", description=f"RSName english description {self.random_str}"),
+                LocalizedDescription(language="japanese", description=f"RSName japanese description {self.random_str}")
+            ]
+        )
+    
+
+    def __update_strategy(self, strategy=None, upsert = False):
+        """
+        Helper to create a reasoning strategy using ai_lab_manager.
+        """
+        return self.ai_lab_manager.update_reasoning_strategy(
+            strategy=self.strategy_to_update if strategy is None else strategy,
+            upsert=upsert
+        )
+    
+
+    def test_update_strategy_full_data(self):
+        self.updated_strategy = self.__update_strategy()
+
+        self.assertEqual(self.updated_strategy.name, self.strategy_to_update.name)
+        self.assertEqual(self.updated_strategy.system_prompt, self.strategy_to_update.system_prompt)
+
+        for locale in self.updated_strategy.localized_descriptions:
+            self.assertIn(
+                self.random_str, 
+                locale.description,
+                "Expected the localized description to be updated correctly"
+            )
+
+
+    def test_update_strategy_no_name(self):  
+        self.strategy_to_update.name = None
+
+        with self.assertRaises(APIError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "ReasoningStrategy name cannot be empty",
+            str(exception.exception),
+            "The expected error about empty name was not returned"
+        )
+    
+
+    def test_update_strategy_no_system_prompt(self):
+        self.strategy_to_update.system_prompt = None
+        
+        with self.assertRaises(APIError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "ReasoningStrategy template or systemPrompt are required.",
+            str(exception.exception),
+            "The expected error about empty system_prompt was not returned"
+        )
+
+
+    def test_update_strategy_no_public_name(self):
+        self.strategy_to_update.access_scope = "public"
+        with self.assertRaises(APIError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "ReasoningStrategy publicName is required for public strategies",
+            str(exception.exception),
+            "The expected error about missing public name was not returned"
+        )
+
+
+    def test_update_strategy_no_access_scope(self):
+        self.strategy_to_update.access_scope = ""
+        with self.assertRaises(ValueError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "Access scope must be either 'public' or 'private'",
+            str(exception.exception),
+            "The expected error about missing access scope was not returned"
+        )
+
+    
+    def test_update_strategy_no_type(self):
+        self.strategy_to_update.type = ""
+        with self.assertRaises(ValueError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "Type must be 'addendum'",
+            str(exception.exception),
+            "The expected error about missing type was not returned"
+        )
+
+
+    def test_update_strategy_invalid_type(self):
+        self.strategy_to_update.type = "strategy_type"
+        
+        with self.assertRaises(ValueError) as exception:
+            self.__update_strategy()
+        self.assertIn(
+            "Type must be 'addendum'",
+            str(exception.exception),
+            "The expected error about missing type was not returned"
+        )
+
+    
+    def test_update_strategy_no_localized_descriptions(self):
+        self.strategy_to_update.localized_descriptions = []    
+        updated_strategy = self.__update_strategy()
+        self.assertIsNone(
+            updated_strategy.localized_descriptions,
+            "Expected no localized descriptions after update"
+        )    
+
+    @unittest.skip("Skipping upsert test to avoid creating new strategies during routine testing before having a cleanup mechanism.")
+    def test_update_strategy_upsert(self):			
+        new_id = str(uuid.uuid4())
+        new_strategy = ReasoningStrategy(
+            id=new_id,
+            name=f"UpsertStrategy_{self.random_str}",
+            system_prompt=f"Upsert system prompt {self.random_str}",
+            access_scope="private",
+            type="addendum",
+            localized_descriptions=[
+                LocalizedDescription(language="english", description=f"Upsert description {self.random_str}")
+            ]
+        )
+        upserted_strategy = self.__update_strategy(strategy=new_strategy, upsert=True)
+        self.assertEqual(upserted_strategy.id, new_id, "Expected the reasoning strategy to be created via upsert")

pygeai/tests/integration/lab/tools/test_create_tool.py

@@ -0,0 +1,288 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Tool, ToolParameter
+from pygeai.core.common.exceptions import APIResponseError
+
+
+class TestAILabCreateToolIntegration(TestCase):    
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+        self.new_tool = self.__load_tool()
+        self.created_tool: Tool = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created tool
+        """
+        if isinstance(self.created_tool, Tool):
+
+            self.ai_lab_manager.delete_tool(self.created_tool.id)
+
+    
+    def __load_tool(self):
+        return Tool(
+            name=str(uuid.uuid4()),
+            description="Tool created for sdk testing purposes",
+            scope="builtin",
+            openApi="https://raw.usercontent.com//openapi.json",
+            openApiJson={"openapi": "3.0.0","info": {"title": "Simple API overview","version": "2.0.0"}},
+            accessScope="private",
+            reportEvents="None",
+            parameters=[{"key": "param", "description": "param description", "type":"app", "value":"param value", "data_type": "String", "isRequired": False}],
+        )
+    
+
+    def __create_tool(self, tool=None, automatic_publish=False):
+        """
+        Helper to create a tool using ai_lab_manager.
+        """
+        return self.ai_lab_manager.create_tool(
+            tool=self.new_tool if tool is None else tool,
+            automatic_publish=automatic_publish
+        )
+
+
+    def test_create_tool_full_data(self):
+        self.created_tool = self.__create_tool()
+        created_tool = self.created_tool
+        tool = self.new_tool
+        self.assertTrue(isinstance(created_tool, Tool), "Expected a created tool")
+
+        # Assert the main fields of the created tool
+        self.assertIsNotNone(created_tool.id)
+        self.assertEqual(created_tool.name, tool.name)
+        self.assertEqual(created_tool.description, tool.description)
+        self.assertEqual(created_tool.scope, tool.scope)
+        self.assertEqual(created_tool.access_scope, tool.access_scope)
+        self.assertEqual(created_tool.open_api, tool.open_api)
+        self.assertEqual(created_tool.status, "active")
+
+        # Assert agentData fields
+        tool_param = created_tool.parameters[0]
+        self.assertTrue(isinstance(tool_param, ToolParameter), "Expected parameters to be of type ToolParameter")
+        self.assertEqual(tool_param.key, tool.parameters[0].key)
+        self.assertEqual(tool_param.data_type, tool.parameters[0].data_type)
+        self.assertEqual(tool_param.description, tool.parameters[0].description)
+        self.assertEqual(tool_param.is_required, tool.parameters[0].is_required)
+        self.assertEqual(tool_param.type, tool.parameters[0].type)
+        self.assertEqual(tool_param.value, tool.parameters[0].value)        
+
+
+    def test_create_tool_minimum_required_data(self):
+        self.new_tool = Tool(
+            name=str(uuid.uuid4()),
+            description="Tool created for sdk testing purposes",
+            scope="builtin"
+        )
+        self.created_tool = self.__create_tool()
+        tool = self.new_tool
+
+        self.assertIsNotNone(self.created_tool.id)
+        self.assertEqual(self.created_tool.name, tool.name)
+        self.assertEqual(self.created_tool.description, tool.description)
+
+
+    def test_create_tool_without_required_data(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            
+            with self.subTest(input=auto_publish): 
+                self.new_tool = Tool(
+                        name=str(uuid.uuid4())
+                    )
+                created_tool = self.__create_tool(automatic_publish=auto_publish)
+                self.assertTrue(isinstance(created_tool, Tool), "Expected a created tool")    
+
+
+    def test_create_tool_no_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.new_tool.name = ""
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__create_tool(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Tool name cannot be empty.",
+                    str(exception.exception),
+                    f"Expected an error about the missing tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_create_tool_duplicated_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+
+            with self.subTest(input=auto_publish):
+                self.new_tool.name = "sdk_project_gemini_tool"
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__create_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Tool already exists [name=sdk_project_gemini_tool]..",
+                    str(exception.exception),                    
+                    f"Expected an error about duplicated tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_create_tool_invalid_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                new_tool = self.__load_tool()
+                new_tool2 = self.__load_tool()
+
+                with self.assertRaises(APIResponseError) as exception:
+                    new_tool.name = f"{new_tool.name}:invalid"
+                    self.__create_tool(tool=new_tool, automatic_publish=auto_publish)
+                self.assertIn(
+                    "Invalid character in name (: is not allowed).",
+                    str(exception.exception),                    
+                    f"Expected an error about invalid character (:) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+                with self.assertRaises(APIResponseError) as exception:
+                    new_tool2.name = f"{new_tool2.name}/invalid"
+                    self.__create_tool(tool=new_tool2, automatic_publish=auto_publish)
+                self.assertIn(
+                    "Invalid character in name (/ is not allowed).",
+                    str(exception.exception),                    
+                    f"Expected an error about invalid character (/) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+        
+
+    def test_create_tool_invalid_access_scope(self):
+        self.new_tool.access_scope = "project" 
+        with self.assertRaises(ValueError) as exc:
+            self.__create_tool()
+        self.assertEqual(
+            str(exc.exception),
+            "Access scope must be one of public, private.",
+            "Expected a ValueError exception for invalid access scope"
+        )   
+
+
+    def test_create_tool_default_scope(self):
+        self.new_tool.access_scope = None
+        self.created_tool = self.__create_tool()
+
+        self.assertEqual(self.created_tool.access_scope, "private", "Expected the default access scope to be 'private' when not specified")
+
+
+    def test_create_tool_no_public_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+
+            with self.subTest(input=auto_publish):
+                self.new_tool.access_scope = "public"
+                self.new_tool.public_name = None
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__create_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Tool publicName is required for tools with accessScope=public.",
+                    str(exception.exception),                    
+                    f"Expected an error about missing publicName for public access scope with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+   
+    def test_create_tool_invalid_public_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish): 
+                self.new_tool.access_scope = "public"
+                self.new_tool.public_name = "com.sdk.testing#"  # Add invalid character to public name
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__create_tool(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Invalid public name, it can only contain lowercase letters, numbers, periods (.), dashes (-), and underscores (_). Please remove any other characters.",
+                    str(exception.exception),                    
+                    f"The expected error about invalid publicName was not returned when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_tool_duplicated_public_name(self):
+        test_params = [ True, False ]
+
+        # Set the scope as public and assign a public name
+        self.new_tool.access_scope = "public"
+        self.new_tool.public_name=f"public_{self.new_tool.name}"
+        self.created_tool = self.__create_tool()
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+
+                # Create a new with the same public name of created_tool
+                duplicated_pn_tool = self.__load_tool()
+                duplicated_pn_tool.access_scope = "public"
+                duplicated_pn_tool.public_name = self.created_tool.public_name
+                
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__create_tool(tool=duplicated_pn_tool, automatic_publish=auto_publish)
+                self.assertIn(
+                    f"Tool already exists [publicName={self.created_tool.public_name}].",
+                    str(exception.exception),                   
+                    f"Expected an error about the duplicated public name when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_tool_api_scope_with_no_open_api(self):
+        self.new_tool.scope = "api"
+        with self.assertRaises(ValueError) as exception:
+            self.new_tool.openApi = ""
+        self.assertIn(
+            '"Tool" object has no field "openApi"',
+            str(exception.exception),
+            "Expected a validation error when openApi is not provided for api scope"
+        )
+
+    
+    def test_create_tool_api_scope_with_no_open_api_json(self):
+        self.new_tool.scope = "api"
+        with self.assertRaises(ValueError) as exception:
+            self.new_tool.openApiJson = ""
+            
+        self.assertIn(
+            '"Tool" object has no field "openApiJson"',
+            str(exception.exception),
+            "Expected a validation error when openApiJson is not provided for api scope"
+        )
+
+    
+    def test_create_tool_invalid_scope(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish): 
+                
+                with self.assertRaises(ValueError) as exception:
+                    self.new_tool.scope = "source"
+                    self.__create_tool()
+                self.assertIn(
+                    'Scope must be one of builtin, external, api, proxied',
+                    str(exception.exception),
+                    "Expected a validation error about allowed values for instructions"
+                )
+
+
+    def test_create_tool_autopublish(self): 
+        self.created_tool = self.__create_tool(automatic_publish=True)
+        self.assertFalse(self.created_tool.is_draft, "Expected the tool to be published automatically")
+    
+    
+    def test_create_tool_autopublish_private_scope(self):
+        self.new_tool.access_scope = "private"
+
+        self.created_tool = self.__create_tool(automatic_publish=True)
+        self.assertFalse(self.created_tool.is_draft, "Expected the tool to be published automatically even with private scope")

pygeai/tests/integration/lab/tools/test_delete_tool.py

@@ -0,0 +1,87 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Tool
+from pygeai.core.common.exceptions import APIResponseError, MissingRequirementException, InvalidAPIResponseException
+
+ai_lab_manager: AILabManager
+
+class TestAILabDeleteToolIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        
+
+    def __create_tool(self):
+        """
+        Helper to create a tool
+        """
+        tool = Tool(
+            name=str(uuid.uuid4()),
+            description="Agent that translates from any language to english.",
+            scope="builtin"
+        )
+
+
+        return self.ai_lab_manager.create_tool(
+            tool=tool
+        )
+
+    def __delete_tool(self, tool_id: str = None, tool_name: str = None):
+        return self.ai_lab_manager.delete_tool(tool_id=tool_id, tool_name=tool_name)
+    
+
+    def test_delete_tool_by_id(self):         
+        created_tool = self.__create_tool()     
+        deleted_tool = self.__delete_tool(tool_id=created_tool.id)
+
+        self.assertEqual(
+            deleted_tool.content,
+            "Tool deleted successfully",
+            "Expected confirmation message after deletion"            
+        )
+
+
+    def test_delete_tool_by_name(self):         
+        created_tool = self.__create_tool()     
+        deleted_tool = self.__delete_tool(tool_name=created_tool.name)
+
+        self.assertEqual(
+            deleted_tool.content,
+            "Tool deleted successfully",
+            "Expected confirmation message after deletion"            
+        )
+
+
+    def test_delete_tool_no_id_nor_name(self):
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__delete_tool()   
+        self.assertIn(
+            "Either tool_id or tool_name must be provided",
+            str(exception.exception),
+            "Expected error message when neither tool_id nor tool_name is provided"
+        )
+
+
+    def test_delete_tool_invalid_id_valid_name(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        created_tool = self.__create_tool() 
+        with self.assertRaises(APIResponseError) as exception:
+            self.__delete_tool(tool_name=created_tool.name, tool_id=invalid_id)
+
+        self.assertIn(
+            f"Tool not found [IdOrName= {invalid_id}].",
+            str(exception.exception),
+            "Expected error message for valid tool name and invalid tool id"
+        )
+
+
+    def test_delete_tool_invalid_name_valid_id(self):
+        created_tool = self.__create_tool()     
+        deleted_tool = self.__delete_tool(tool_id=created_tool.id, tool_name="toolName")
+        
+        self.assertEqual(
+            deleted_tool.content,
+            "Tool deleted successfully",
+            "Expected confirmation message after deletion"            
+        )