pygeai 0.4.0b12__py3-none-any.whl → 0.6.0b3__py3-none-any.whl

pygeai/tests/lab/strategies/test_clients.py

@@ -1,5 +1,5 @@
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch
 from json import JSONDecodeError
 from pygeai.lab.strategies.clients import ReasoningStrategyClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException
@@ -10,18 +10,16 @@ class TestReasoningStrategyClient(unittest.TestCase):
     python -m unittest pygeai.tests.lab.strategies.test_clients.TestReasoningStrategyClient
     """
     def setUp(self):
-        with patch('pygeai.core.base.clients.BaseClient.__init__', return_value=None):
-            self.client = ReasoningStrategyClient()
-        self.mock_response = MagicMock()
-        self.client.api_service = MagicMock()
         self.project_id = "project-123"
+        self.client = ReasoningStrategyClient(api_key="test_key", base_url="https://test.url", project_id=self.project_id)
         self.reasoning_strategy_id = "strat-123"
         self.reasoning_strategy_name = "TestStrategy"
 
-    def test_list_reasoning_strategies_success(self):
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_list_reasoning_strategies_success(self, mock_get):
         expected_response = {"strategies": [{"id": "strat-1", "name": "Strategy1"}]}
-        self.mock_response.json.return_value = expected_response
-        self.client.api_service.get.return_value = self.mock_response
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = expected_response
 
         result = self.client.list_reasoning_strategies(
             name="Strategy1",
@@ -32,8 +30,8 @@ class TestReasoningStrategyClient(unittest.TestCase):
         )
 
         self.assertEqual(result, expected_response)
-        self.client.api_service.get.assert_called_once()
-        call_args = self.client.api_service.get.call_args
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
         params = call_args[1]['params']
         self.assertEqual(params['name'], "Strategy1")
         self.assertEqual(params['start'], "0")
@@ -41,16 +39,17 @@ class TestReasoningStrategyClient(unittest.TestCase):
         self.assertTrue(params['allowExternal'])
         self.assertEqual(params['accessScope'], "public")
 
-    def test_list_reasoning_strategies_json_decode_error(self):
-        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
-        self.mock_response.text = "Raw response text"
-        self.mock_response.status_code = 500
-        self.client.api_service.get.return_value = self.mock_response
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_list_reasoning_strategies_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Raw response text"
+        mock_response.status_code = 500
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.client.list_reasoning_strategies()
 
-        self.client.api_service.get.assert_called_once()
+        mock_get.assert_called_once()
         self.assertIn("Unable to list reasoning strategies", str(context.exception))
 
     def test_list_reasoning_strategies_invalid_access_scope(self):
@@ -59,7 +58,8 @@ class TestReasoningStrategyClient(unittest.TestCase):
 
         self.assertEqual(str(context.exception), "Access scope must be either 'public' or 'private'.")
 
-    def test_create_reasoning_strategy_success(self):
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_create_reasoning_strategy_success(self, mock_post):
         name = "TestStrategy"
         system_prompt = "Test system prompt"
         access_scope = "public"
@@ -67,11 +67,10 @@ class TestReasoningStrategyClient(unittest.TestCase):
         localized_descriptions = [{"language": "english", "description": "Test description"}]
         automatic_publish = True
         expected_response = {"id": "strat-123", "name": name}
-        self.mock_response.json.return_value = expected_response
-        self.client.api_service.post.return_value = self.mock_response
+        mock_response = mock_post.return_value
+        mock_response.json.return_value = expected_response
 
         result = self.client.create_reasoning_strategy(
-            project_id=self.project_id,
             name=name,
             system_prompt=system_prompt,
             access_scope=access_scope,
@@ -81,8 +80,8 @@ class TestReasoningStrategyClient(unittest.TestCase):
         )
 
         self.assertEqual(result, expected_response)
-        self.client.api_service.post.assert_called_once()
-        call_args = self.client.api_service.post.call_args
+        mock_post.assert_called_once()
+        call_args = mock_post.call_args
         data = call_args[1]['data']['strategyDefinition']
         self.assertEqual(data['name'], name)
         self.assertEqual(data['systemPrompt'], system_prompt)
@@ -93,25 +92,26 @@ class TestReasoningStrategyClient(unittest.TestCase):
         headers = call_args[1]['headers']
         self.assertEqual(headers['ProjectId'], self.project_id)
 
-    def test_create_reasoning_strategy_json_decode_error(self):
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_create_reasoning_strategy_json_decode_error(self, mock_post):
         name = "TestStrategy"
         system_prompt = "Test system prompt"
-        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
-        self.mock_response.text = "Raw response text"
-        self.mock_response.status_code = 500
-        self.client.api_service.post.return_value = self.mock_response
+        mock_response = mock_post.return_value
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Raw response text"
+        mock_response.status_code = 500
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.client.create_reasoning_strategy(
-                project_id=self.project_id,
                 name=name,
                 system_prompt=system_prompt
             )
 
-        self.client.api_service.post.assert_called_once()
+        mock_post.assert_called_once()
         self.assertIn("Unable to create reasoning strategy", str(context.exception))
 
-    def test_update_reasoning_strategy_success(self):
+    @patch("pygeai.core.services.rest.ApiService.put")
+    def test_update_reasoning_strategy_success(self, mock_put):
         name = "UpdatedStrategy"
         system_prompt = "Updated prompt"
         access_scope = "private"
@@ -120,11 +120,10 @@ class TestReasoningStrategyClient(unittest.TestCase):
         automatic_publish = True
         upsert = False
         expected_response = {"id": self.reasoning_strategy_id, "name": name}
-        self.mock_response.json.return_value = expected_response
-        self.client.api_service.put.return_value = self.mock_response
+        mock_response = mock_put.return_value
+        mock_response.json.return_value = expected_response
 
         result = self.client.update_reasoning_strategy(
-            project_id=self.project_id,
             reasoning_strategy_id=self.reasoning_strategy_id,
             name=name,
             system_prompt=system_prompt,
@@ -136,8 +135,8 @@ class TestReasoningStrategyClient(unittest.TestCase):
         )
 
         self.assertEqual(result, expected_response)
-        self.client.api_service.put.assert_called_once()
-        call_args = self.client.api_service.put.call_args
+        mock_put.assert_called_once()
+        call_args = mock_put.call_args
         data = call_args[1]['data']['strategyDefinition']
         self.assertEqual(data['name'], name)
         self.assertEqual(data['systemPrompt'], system_prompt)
@@ -148,27 +147,26 @@ class TestReasoningStrategyClient(unittest.TestCase):
         headers = call_args[1]['headers']
         self.assertEqual(headers['ProjectId'], self.project_id)
 
-    def test_update_reasoning_strategy_json_decode_error(self):
+    @patch("pygeai.core.services.rest.ApiService.put")
+    def test_update_reasoning_strategy_json_decode_error(self, mock_put):
         name = "UpdatedStrategy"
-        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
-        self.mock_response.text = "Raw response text"
-        self.mock_response.status_code = 500
-        self.client.api_service.put.return_value = self.mock_response
+        mock_response = mock_put.return_value
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Raw response text"
+        mock_response.status_code = 500
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.client.update_reasoning_strategy(
-                project_id=self.project_id,
                 reasoning_strategy_id=self.reasoning_strategy_id,
                 name=name
             )
 
-        self.client.api_service.put.assert_called_once()
+        mock_put.assert_called_once()
         self.assertIn("Unable to update reasoning strategy", str(context.exception))
 
     def test_update_reasoning_strategy_invalid_access_scope(self):
         with self.assertRaises(ValueError) as context:
             self.client.update_reasoning_strategy(
-                project_id=self.project_id,
                 reasoning_strategy_id=self.reasoning_strategy_id,
                 access_scope="invalid"
             )
@@ -178,59 +176,61 @@ class TestReasoningStrategyClient(unittest.TestCase):
     def test_update_reasoning_strategy_invalid_type(self):
         with self.assertRaises(ValueError) as context:
             self.client.update_reasoning_strategy(
-                project_id=self.project_id,
                 reasoning_strategy_id=self.reasoning_strategy_id,
                 strategy_type="invalid"
             )
 
         self.assertEqual(str(context.exception), "Type must be 'addendum'.")
 
-    def test_get_reasoning_strategy_success_with_id(self):
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_reasoning_strategy_success_with_id(self, mock_get):
         expected_response = {"id": self.reasoning_strategy_id, "name": "TestStrategy"}
-        self.mock_response.json.return_value = expected_response
-        self.client.api_service.get.return_value = self.mock_response
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = expected_response
 
         result = self.client.get_reasoning_strategy(
-            project_id=self.project_id,
             reasoning_strategy_id=self.reasoning_strategy_id
         )
 
         self.assertEqual(result, expected_response)
-        self.client.api_service.get.assert_called_once()
-        headers = self.client.api_service.get.call_args[1]['headers']
+        mock_get.assert_called_once()
+        headers = mock_get.call_args[1]['headers']
         self.assertEqual(headers['ProjectId'], self.project_id)
 
-    def test_get_reasoning_strategy_success_with_name(self):
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_reasoning_strategy_success_with_name(self, mock_get):
         expected_response = {"name": self.reasoning_strategy_name}
-        self.mock_response.json.return_value = expected_response
-        self.client.api_service.get.return_value = self.mock_response
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = expected_response
 
         result = self.client.get_reasoning_strategy(
-            project_id=self.project_id,
             reasoning_strategy_name=self.reasoning_strategy_name
         )
 
         self.assertEqual(result, expected_response)
-        self.client.api_service.get.assert_called_once()
+        mock_get.assert_called_once()
 
-    def test_get_reasoning_strategy_json_decode_error(self):
-        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
-        self.mock_response.text = "Raw response text"
-        self.mock_response.status_code = 500
-        self.client.api_service.get.return_value = self.mock_response
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_reasoning_strategy_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Raw response text"
+        mock_response.status_code = 500
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.client.get_reasoning_strategy(
-                project_id=self.project_id,
                 reasoning_strategy_id=self.reasoning_strategy_id
             )
 
-        self.client.api_service.get.assert_called_once()
+        mock_get.assert_called_once()
         self.assertIn("Unable to retrieve reasoning strategy", str(context.exception))
 
     def test_get_reasoning_strategy_invalid_input(self):
         with self.assertRaises(ValueError) as context:
-            self.client.get_reasoning_strategy(project_id=self.project_id)
+            self.client.get_reasoning_strategy()
 
         self.assertEqual(str(context.exception), "Either reasoning_strategy_id or reasoning_strategy_name must be provided.")
 
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/lab/test_managers.py

@@ -205,17 +205,14 @@ class TestAILabManager(unittest.TestCase):
         self.assertIsInstance(result, list)
 
     @patch('pygeai.lab.tools.clients.ToolClient.set_parameter')
-    @patch('pygeai.lab.tools.mappers.ToolMapper.map_to_tool')
-    def test_set_parameter_success(self, mock_map_to_tool, mock_set_parameter):
-        mock_set_parameter.return_value = {"data": "test_data"}
-        mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
+    def test_set_parameter_success(self, mock_set_parameter):
+        mock_set_parameter.return_value = {"status": "success"}
         parameters = [ToolParameter(key="test_key", data_type="String", description="test_desc", is_required=True)]
 
         result = self.manager.set_parameter(tool_id=self.tool_id, parameters=parameters)
 
         mock_set_parameter.assert_called_once()
-        mock_map_to_tool.assert_called_once_with({"data": "test_data"})
-        self.assertIsInstance(result, Tool)
+        self.assertIsNotNone(result)
 
     @patch('pygeai.lab.strategies.clients.ReasoningStrategyClient.list_reasoning_strategies')
     @patch('pygeai.lab.strategies.mappers.ReasoningStrategyMapper.map_to_reasoning_strategy_list')

pygeai/tests/lab/test_models.py

@@ -772,12 +772,12 @@ class TestLabModels(TestCase):
             "name": "ApiTool",
             "description": "API tool",
             "scope": "api"
-            # Missing open_api or open_api_json, should trigger validation error
+            # Missing open_api or open_api_json - validation currently commented out
         }
-        with self.assertRaises(ValueError) as context:
-            Tool.model_validate(tool_data)
-        self.assertIn("for scope='api', either open_api or open_api_json must be provided",
-                      str(context.exception).lower())
+        # Validation is currently commented out in the model, so this should not raise
+        tool = Tool.model_validate(tool_data)
+        self.assertEqual(tool.name, "ApiTool")
+        self.assertEqual(tool.scope, "api")
 
     def test_tool_duplicate_parameter_keys(self):
         tool_data = {
@@ -789,9 +789,10 @@ class TestLabModels(TestCase):
                 {"key": "param1", "dataType": "Integer", "description": "Param 1 duplicate", "isRequired": False}
             ]
         }
-        with self.assertRaises(ValueError) as context:
-            Tool.model_validate(tool_data)
-        self.assertIn("all parameter keys must be unique within the tool", str(context.exception).lower())
+        # Validation is currently commented out in the model, so this should not raise
+        tool = Tool.model_validate(tool_data)
+        self.assertEqual(tool.name, "DuplicateTool")
+        self.assertEqual(len(tool.parameters), 2)
 
     def test_knowledge_base_invalid_artifacts(self):
         kb_data = {

pygeai/tests/lab/tools/test_clients.py

@@ -15,8 +15,8 @@ class TestToolClient(unittest.TestCase):
     """
 
     def setUp(self):
-        self.tool_client = ToolClient()
         self.project_id = "project-123"
+        self.tool_client = ToolClient(api_key="test_key", base_url="https://test.url", project_id=self.project_id)
         self.tool_id = "tool-123"
         self.tool_name = "TestTool"
         self.tool_public_name = "test-tool"
@@ -36,10 +36,10 @@ class TestToolClient(unittest.TestCase):
         automatic_publish = True
         expected_response = {"id": "tool-123", "name": name}
         mock_response = mock_post.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.create_tool(
-            project_id=self.project_id,
             name=name,
             description=description,
             scope=scope,
@@ -74,7 +74,6 @@ class TestToolClient(unittest.TestCase):
     def test_create_tool_invalid_scope(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.create_tool(
-                project_id=self.project_id,
                 name="TestTool",
                 scope="invalid_scope"
             )
@@ -83,7 +82,6 @@ class TestToolClient(unittest.TestCase):
     def test_create_tool_invalid_access_scope(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.create_tool(
-                project_id=self.project_id,
                 name="TestTool",
                 access_scope="invalid_access"
             )
@@ -92,7 +90,6 @@ class TestToolClient(unittest.TestCase):
     def test_create_tool_invalid_report_events(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.create_tool(
-                project_id=self.project_id,
                 name="TestTool",
                 report_events="invalid_event"
             )
@@ -108,7 +105,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.create_tool(
-                project_id=self.project_id,
                 name=name
             )
 
@@ -119,10 +115,10 @@ class TestToolClient(unittest.TestCase):
     def test_list_tools_success(self, mock_get):
         expected_response = {"tools": [{"id": "tool-1", "name": "Tool1"}]}
         mock_response = mock_get.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.list_tools(
-            project_id=self.project_id,
             id="tool-1",
             count="50",
             access_scope="public",
@@ -150,7 +146,6 @@ class TestToolClient(unittest.TestCase):
     def test_list_tools_invalid_scope(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.list_tools(
-                project_id=self.project_id,
                 scope="invalid_scope"
             )
         self.assertEqual(str(context.exception), f"Scope must be one of {', '.join(VALID_SCOPES)}.")
@@ -164,7 +159,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.list_tools(
-                project_id=self.project_id,
                 scope="api"
             )
 
@@ -175,10 +169,10 @@ class TestToolClient(unittest.TestCase):
     def test_get_tool_success(self, mock_get):
         expected_response = {"id": self.tool_id, "name": "TestTool"}
         mock_response = mock_get.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.get_tool(
-            project_id=self.project_id,
             tool_id=self.tool_id,
             revision="1",
             version=0,
@@ -207,7 +201,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.get_tool(
-                project_id=self.project_id,
                 tool_id=self.tool_id
             )
 
@@ -216,16 +209,14 @@ class TestToolClient(unittest.TestCase):
 
     @patch("pygeai.core.services.rest.ApiService.delete")
     def test_delete_tool_success_with_id(self, mock_delete):
-        expected_response = {"status": "deleted"}
         mock_response = mock_delete.return_value
-        mock_response.json.return_value = expected_response
+        mock_response.status_code = 204
 
         result = self.tool_client.delete_tool(
-            project_id=self.project_id,
             tool_id=self.tool_id
         )
 
-        self.assertEqual(result, expected_response)
+        self.assertEqual(result, {})
         mock_delete.assert_called_once_with(
             endpoint=DELETE_TOOL_V2.format(toolId=self.tool_id),
             headers=mock_delete.call_args[1]['headers']
@@ -235,16 +226,14 @@ class TestToolClient(unittest.TestCase):
 
     @patch("pygeai.core.services.rest.ApiService.delete")
     def test_delete_tool_success_with_name(self, mock_delete):
-        expected_response = {"status": "deleted"}
         mock_response = mock_delete.return_value
-        mock_response.json.return_value = expected_response
+        mock_response.status_code = 204
 
         result = self.tool_client.delete_tool(
-            project_id=self.project_id,
             tool_name=self.tool_name
         )
 
-        self.assertEqual(result, expected_response)
+        self.assertEqual(result, {})
         mock_delete.assert_called_once_with(
             endpoint=DELETE_TOOL_V2.format(toolId=self.tool_name),
             headers=mock_delete.call_args[1]['headers']
@@ -254,7 +243,7 @@ class TestToolClient(unittest.TestCase):
 
     def test_delete_tool_invalid_input(self):
         with self.assertRaises(ValueError) as context:
-            self.tool_client.delete_tool(project_id=self.project_id)
+            self.tool_client.delete_tool()
         self.assertEqual(str(context.exception), "Either tool_id or tool_name must be provided.")
 
     @patch("pygeai.core.services.rest.ApiService.delete")
@@ -266,11 +255,10 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.delete_tool(
-                project_id=self.project_id,
                 tool_id=self.tool_id
             )
 
-        self.assertEqual(str(context.exception), f"Unable to delete tool {self.tool_id} from project {self.project_id}: Invalid JSON response")
+        self.assertEqual(str(context.exception), f"Unable to delete tool {self.tool_id} in project {self.project_id}: Invalid JSON response")
         mock_delete.assert_called_once()
 
     @patch("pygeai.core.services.rest.ApiService.put")
@@ -288,10 +276,10 @@ class TestToolClient(unittest.TestCase):
         upsert = False
         expected_response = {"id": self.tool_id, "name": name}
         mock_response = mock_put.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.update_tool(
-            project_id=self.project_id,
             tool_id=self.tool_id,
             name=name,
             description=description,
@@ -333,10 +321,10 @@ class TestToolClient(unittest.TestCase):
         name = "UpsertedTool"
         expected_response = {"id": self.tool_id, "name": name}
         mock_response = mock_put.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.update_tool(
-            project_id=self.project_id,
             tool_id=self.tool_id,
             name=name,
             upsert=True
@@ -352,7 +340,6 @@ class TestToolClient(unittest.TestCase):
     def test_update_tool_invalid_scope(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.update_tool(
-                project_id=self.project_id,
                 tool_id=self.tool_id,
                 scope="invalid_scope"
             )
@@ -361,7 +348,6 @@ class TestToolClient(unittest.TestCase):
     def test_update_tool_invalid_access_scope(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.update_tool(
-                project_id=self.project_id,
                 tool_id=self.tool_id,
                 access_scope="invalid_access"
             )
@@ -370,7 +356,6 @@ class TestToolClient(unittest.TestCase):
     def test_update_tool_invalid_report_events(self):
         with self.assertRaises(ValueError) as context:
             self.tool_client.update_tool(
-                project_id=self.project_id,
                 tool_id=self.tool_id,
                 report_events="invalid_event"
             )
@@ -385,7 +370,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.update_tool(
-                project_id=self.project_id,
                 tool_id=self.tool_id,
                 name="UpdatedTool"
             )
@@ -398,10 +382,10 @@ class TestToolClient(unittest.TestCase):
         revision = "2"
         expected_response = {"status": "published"}
         mock_response = mock_post.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.publish_tool_revision(
-            project_id=self.project_id,
             tool_id=self.tool_id,
             revision=revision
         )
@@ -425,7 +409,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.publish_tool_revision(
-                project_id=self.project_id,
                 tool_id=self.tool_id,
                 revision=revision
             )
@@ -437,10 +420,10 @@ class TestToolClient(unittest.TestCase):
     def test_get_parameter_success_with_id(self, mock_get):
         expected_response = {"parameters": [{"key": "param1"}]}
         mock_response = mock_get.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.get_parameter(
-            project_id=self.project_id,
             tool_id=self.tool_id,
             revision="1",
             version=0,
@@ -464,10 +447,10 @@ class TestToolClient(unittest.TestCase):
     def test_get_parameter_success_with_public_name(self, mock_get):
         expected_response = {"parameters": [{"key": "param1"}]}
         mock_response = mock_get.return_value
+        mock_response.status_code = 200
         mock_response.json.return_value = expected_response
 
         result = self.tool_client.get_parameter(
-            project_id=self.project_id,
             tool_public_name=self.tool_public_name,
             revision="1",
             version=0,
@@ -487,7 +470,7 @@ class TestToolClient(unittest.TestCase):
 
     def test_get_parameter_invalid_input(self):
         with self.assertRaises(ValueError) as context:
-            self.tool_client.get_parameter(project_id=self.project_id)
+            self.tool_client.get_parameter()
         self.assertEqual(str(context.exception), "Either tool_id or tool_public_name must be provided.")
 
     @patch("pygeai.core.services.rest.ApiService.get")
@@ -499,7 +482,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.get_parameter(
-                project_id=self.project_id,
                 tool_id=self.tool_id
             )
 
@@ -508,17 +490,15 @@ class TestToolClient(unittest.TestCase):
 
     @patch("pygeai.core.services.rest.ApiService.post")
     def test_set_parameter_success_with_id(self, mock_post):
-        expected_response = {"status": "updated"}
         mock_response = mock_post.return_value
-        mock_response.json.return_value = expected_response
+        mock_response.status_code = 204
 
         result = self.tool_client.set_parameter(
-            project_id=self.project_id,
             tool_id=self.tool_id,
             parameters=self.parameters
         )
 
-        self.assertEqual(result, expected_response)
+        self.assertEqual(result, {})
         mock_post.assert_called_once_with(
             endpoint=SET_PARAMETER_V2.format(toolPublicName=self.tool_id),
             headers=mock_post.call_args[1]['headers'],
@@ -529,17 +509,15 @@ class TestToolClient(unittest.TestCase):
 
     @patch("pygeai.core.services.rest.ApiService.post")
     def test_set_parameter_success_with_public_name(self, mock_post):
-        expected_response = {"status": "updated"}
         mock_response = mock_post.return_value
-        mock_response.json.return_value = expected_response
+        mock_response.status_code = 204
 
         result = self.tool_client.set_parameter(
-            project_id=self.project_id,
             tool_public_name=self.tool_public_name,
             parameters=self.parameters
         )
 
-        self.assertEqual(result, expected_response)
+        self.assertEqual(result, {})
         mock_post.assert_called_once_with(
             endpoint=SET_PARAMETER_V2.format(toolPublicName=self.tool_public_name),
             headers=mock_post.call_args[1]['headers'],
@@ -548,11 +526,11 @@ class TestToolClient(unittest.TestCase):
 
     def test_set_parameter_invalid_input(self):
         with self.assertRaises(ValueError) as context:
-            self.tool_client.set_parameter(project_id=self.project_id, parameters=self.parameters)
+            self.tool_client.set_parameter(parameters=self.parameters)
         self.assertEqual(str(context.exception), "Either tool_id or tool_public_name must be provided.")
 
         with self.assertRaises(ValueError) as context:
-            self.tool_client.set_parameter(project_id=self.project_id, tool_id=self.tool_id, parameters=[])
+            self.tool_client.set_parameter(tool_id=self.tool_id, parameters=[])
         self.assertEqual(str(context.exception), "Parameters list must be provided and non-empty.")
 
     @patch("pygeai.core.services.rest.ApiService.post")
@@ -564,7 +542,6 @@ class TestToolClient(unittest.TestCase):
 
         with self.assertRaises(InvalidAPIResponseException) as context:
             self.tool_client.set_parameter(
-                project_id=self.project_id,
                 tool_id=self.tool_id,
                 parameters=self.parameters
             )