pygeai 0.2.7b36__py3-none-any.whl → 0.2.7b38__py3-none-any.whl

pygeai/tests/integration/lab/agents/test_update_agent.py

@@ -1,9 +1,9 @@
 from unittest import TestCase
-import unittest
 import uuid
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model, Sampling, PromptExample, PromptOutput
 from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIError
 
 
 class TestAILabUpdateAgentIntegration(TestCase):    
@@ -93,11 +93,12 @@ class TestAILabUpdateAgentIntegration(TestCase):
         self.agent_to_update.name = ""
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
-        
-                updated_agent = self.__update_agent(automatic_publish=auto_publish)
-                self.assertEqual(
-                    updated_agent.errors[0].description,
-                    "Agent name cannot be empty.",
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "Error received while updating agent: errors=[Error(id=2007, description='Agent name cannot be empty.')]",
+                    str(exception.exception),
                     f"Expected error about missing agent name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
 
@@ -108,10 +109,12 @@ class TestAILabUpdateAgentIntegration(TestCase):
 
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
-                updated_agent = self.__update_agent(automatic_publish=auto_publish)
-                self.assertEqual(
-                    updated_agent.errors[0].description,
-                    "Agent already exists [name=AritmeticaExpert]",
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "Agent already exists [name=AritmeticaExpert].",
+                    str(exception.exception),
                     f"Expected error about duplicated agent name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
 
@@ -122,17 +125,18 @@ class TestAILabUpdateAgentIntegration(TestCase):
 
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
-        
-                updated_agent = self.__update_agent(automatic_publish=auto_publish)
 
-                self.assertEqual(
-                    updated_agent.errors[0].description,
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
                     "Invalid character in name (: is not allowed).",
+                    str(exception.exception),
                     f"Expected error about invalid character (:) in name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
-                self.assertEqual(
-                    updated_agent.errors[1].description, 
+                self.assertIn(
                     "Invalid character in name (/ is not allowed).",
+                    str(exception.exception),
                     f"Expected error about invalid character (/) in name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
 
@@ -143,10 +147,12 @@ class TestAILabUpdateAgentIntegration(TestCase):
 
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
-                updated_agent = self.__update_agent(automatic_publish=auto_publish)                
-                self.assertEqual(
-                    updated_agent.errors[0].description, 
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
                     "Agent publicName is required for agents with accessScope=public.",
+                    str(exception.exception),
                     f"Expected error about missing public name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
 
@@ -156,12 +162,13 @@ class TestAILabUpdateAgentIntegration(TestCase):
         self.agent_to_update.public_name = "com.testing.geai.googlesummarizer"
 
         for auto_publish in test_params:
-            with self.subTest(input=auto_publish):                
-                updated_agent = self.__update_agent(automatic_publish=auto_publish)
+            with self.subTest(input=auto_publish): 
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
 
-                self.assertEqual(
-                    updated_agent.errors[0].description, 
+                self.assertIn(
                     "Agent already exists [publicName=com.testing.geai.googlesummarizer].",
+                    str(exception.exception),
                     f"Expected error about duplicated public name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
 
@@ -172,10 +179,12 @@ class TestAILabUpdateAgentIntegration(TestCase):
 
         for auto_publish in test_params:
             with self.subTest(input=auto_publish): 
-                updated_agent = self.__update_agent(automatic_publish=auto_publish)
-                self.assertEqual(
-                    updated_agent.errors[0].description, 
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(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"Expected error about invalid public name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
                 )
 
@@ -189,28 +198,46 @@ class TestAILabUpdateAgentIntegration(TestCase):
                 with self.assertRaises(ValidationError) as exception:
                     self.__update_agent(automatic_publish=auto_publish)
                 
-                    self.assertIn(
-                        """instructions
-                            Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]""",
-                        str(exception.exception),
-                        f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
-                    )
+                self.assertIn(
+                    "instructions",
+                    str(exception.exception),
+                    f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+                self.assertIn(
+                    "Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]",
+                    str(exception.exception),
+                    f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
 
     
-    @unittest.skip("Mismatched error message")
     def test_update_agent_no_model(self):        
         test_params = [ True, False ]
         self.agent_to_update.agent_data.models[0].name = ""
+        
         for auto_publish in test_params:
-            with self.subTest(input=auto_publish): 
-                     
-                with self.assertRaises(ValidationError) as exception:
-                    self.__update_agent(automatic_publish=auto_publish)
-                
-                    self.assertAlmostEqual(
-                        """name
-                           Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]""",
-                        str(exception.exception),
+            with self.subTest(input=auto_publish):
+                if auto_publish == False:
+                    with self.assertRaises(ValidationError) as exception:
+                        self.__update_agent(automatic_publish=auto_publish)
+                    error_msg = str(exception.exception)
+                    
+                    self.assertIn(
+                        "name",
+                        error_msg,
+                        "Expected a validation error about empty model name" 
+                    )
+                    self.assertIn(
+                        "Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]",
+                        error_msg,
+                        "Expected a validation error about empty model name" 
+                    )
+                else:                 
+                    with self.assertRaises(APIError) as exception:
+                        self.__update_agent(automatic_publish=auto_publish)
+                    error_msg = str(exception.exception)
+                    self.assertIn(
+                        "description='Model not found [name=]",
+                        error_msg,
                         "Expected a validation error about allowed values for model name" 
                     )
 

pygeai/tests/lab/test_managers.py

@@ -13,9 +13,9 @@ class TestAILabManager(unittest.TestCase):
     """
     python -m unittest pygeai.tests.lab.test_managers.TestAILabManager
     """
+
     def setUp(self):
-        self.manager = AILabManager(api_key="test_key", base_url="test_url", alias="test_alias")
-        self.project_id = "test_project"
+        self.manager = AILabManager(api_key="test_key", base_url="test_url", alias="test_alias", project_id="test_project")
         self.agent_id = "test_agent"
         self.tool_id = "test_tool"
         self.process_id = "test_process"
@@ -31,7 +31,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_agents.return_value = {"data": "test_data"}
         mock_map_to_agent_list.return_value = AgentList(agents=[])
 
-        result = self.manager.get_agent_list(self.project_id, self.filter_settings)
+        result = self.manager.get_agent_list(self.filter_settings)
 
         mock_list_agents.assert_called_once()
         mock_map_to_agent_list.assert_called_once_with({"data": "test_data"})
@@ -42,7 +42,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_agents.return_value = {"error": {"id": 1, "message": "API error"}}
 
         with self.assertRaises(APIError):
-            self.manager.get_agent_list(self.project_id, self.filter_settings)
+            self.manager.get_agent_list(self.filter_settings)
 
     @patch('pygeai.lab.agents.clients.AgentClient.create_agent')
     @patch('pygeai.lab.agents.mappers.AgentMapper.map_to_agent')
@@ -51,7 +51,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
         agent = Agent(name="test_agent")
 
-        result = self.manager.create_agent(self.project_id, agent, automatic_publish=False)
+        result = self.manager.create_agent(agent, automatic_publish=False)
 
         mock_create_agent.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -64,7 +64,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
         agent = Agent(id=self.agent_id, name="test_agent")
 
-        result = self.manager.update_agent(self.project_id, agent, automatic_publish=False, upsert=False)
+        result = self.manager.update_agent(agent, automatic_publish=False, upsert=False)
 
         mock_update_agent.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -76,7 +76,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_agent.return_value = {"data": "test_data"}
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
 
-        result = self.manager.get_agent(self.project_id, self.agent_id, self.filter_settings)
+        result = self.manager.get_agent(self.agent_id, self.filter_settings)
 
         mock_get_agent.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -88,7 +88,7 @@ class TestAILabManager(unittest.TestCase):
         mock_create_sharing_link.return_value = {"data": "test_data"}
         mock_map_to_sharing_link.return_value = SharingLink(agent_id="test_agent", api_token="test_token", shared_link="test_link")
 
-        result = self.manager.create_sharing_link(self.project_id, self.agent_id)
+        result = self.manager.create_sharing_link(self.agent_id)
 
         mock_create_sharing_link.assert_called_once()
         mock_map_to_sharing_link.assert_called_once_with({"data": "test_data"})
@@ -100,7 +100,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_agent_revision.return_value = {"data": "test_data"}
         mock_map_to_agent.return_value = Agent(id=self.agent_id, name="test_agent")
 
-        result = self.manager.publish_agent_revision(self.project_id, self.agent_id, self.revision)
+        result = self.manager.publish_agent_revision(self.agent_id, self.revision)
 
         mock_publish_agent_revision.assert_called_once()
         mock_map_to_agent.assert_called_once_with({"data": "test_data"})
@@ -112,7 +112,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_agent.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_agent(self.project_id, self.agent_id)
+        result = self.manager.delete_agent(self.agent_id)
 
         mock_delete_agent.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -125,7 +125,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
         tool = Tool(name="test_tool", description="test_desc")
 
-        result = self.manager.create_tool(self.project_id, tool, automatic_publish=False)
+        result = self.manager.create_tool(tool, automatic_publish=False)
 
         mock_create_tool.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -138,7 +138,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
         tool = Tool(id=self.tool_id, name="test_tool", description="test_desc")
 
-        result = self.manager.update_tool(self.project_id, tool, automatic_publish=False, upsert=False)
+        result = self.manager.update_tool(tool, automatic_publish=False, upsert=False)
 
         mock_update_tool.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -150,7 +150,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_tool.return_value = {"data": "test_data"}
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
 
-        result = self.manager.get_tool(self.project_id, self.tool_id, self.filter_settings)
+        result = self.manager.get_tool(self.tool_id, self.filter_settings)
 
         mock_get_tool.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -162,7 +162,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_tool.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_tool(self.project_id, tool_id=self.tool_id)
+        result = self.manager.delete_tool(tool_id=self.tool_id)
 
         mock_delete_tool.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -174,7 +174,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_tools.return_value = {"data": "test_data"}
         mock_map_to_tool_list.return_value = ToolList(tools=[])
 
-        result = self.manager.list_tools(self.project_id, self.filter_settings)
+        result = self.manager.list_tools(self.filter_settings)
 
         mock_list_tools.assert_called_once()
         mock_map_to_tool_list.assert_called_once_with({"data": "test_data"})
@@ -186,7 +186,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_tool_revision.return_value = {"data": "test_data"}
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
 
-        result = self.manager.publish_tool_revision(self.project_id, self.tool_id, self.revision)
+        result = self.manager.publish_tool_revision(self.tool_id, self.revision)
 
         mock_publish_tool_revision.assert_called_once()
         mock_map_to_tool.assert_called_once_with({"data": "test_data"})
@@ -198,7 +198,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_parameter.return_value = {"data": "test_data"}
         mock_map_to_parameter_list.return_value = [ToolParameter(key="test_key", data_type="String", description="test_desc", is_required=True)]
 
-        result = self.manager.get_parameter(self.project_id, tool_id=self.tool_id, filter_settings=self.filter_settings)
+        result = self.manager.get_parameter(tool_id=self.tool_id, filter_settings=self.filter_settings)
 
         mock_get_parameter.assert_called_once()
         mock_map_to_parameter_list.assert_called_once_with({"data": "test_data"})
@@ -211,7 +211,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_tool.return_value = Tool(id=self.tool_id, name="test_tool", description="test_desc")
         parameters = [ToolParameter(key="test_key", data_type="String", description="test_desc", is_required=True)]
 
-        result = self.manager.set_parameter(self.project_id, tool_id=self.tool_id, parameters=parameters)
+        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"})
@@ -236,7 +236,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_strategy.return_value = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum")
         strategy = ReasoningStrategy(name="test_strategy", access_scope="private", type="addendum", localized_descriptions=[])
 
-        result = self.manager.create_reasoning_strategy(self.project_id, strategy, automatic_publish=False)
+        result = self.manager.create_reasoning_strategy(strategy, automatic_publish=False)
 
         mock_create_strategy.assert_called_once()
         mock_map_to_strategy.assert_called_once_with({"data": "test_data"})
@@ -249,7 +249,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_strategy.return_value = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum")
         strategy = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum", localized_descriptions=[])
 
-        result = self.manager.update_reasoning_strategy(self.project_id, strategy, automatic_publish=False, upsert=False)
+        result = self.manager.update_reasoning_strategy(strategy, automatic_publish=False, upsert=False)
 
         mock_update_strategy.assert_called_once()
         mock_map_to_strategy.assert_called_once_with({"data": "test_data"})
@@ -261,7 +261,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_strategy.return_value = {"data": "test_data"}
         mock_map_to_strategy.return_value = ReasoningStrategy(id="test_strategy", name="test_strategy", access_scope="private", type="addendum")
 
-        result = self.manager.get_reasoning_strategy(self.project_id, reasoning_strategy_id="test_strategy")
+        result = self.manager.get_reasoning_strategy(reasoning_strategy_id="test_strategy")
 
         mock_get_strategy.assert_called_once()
         mock_map_to_strategy.assert_called_once_with({"data": "test_data"})
@@ -274,7 +274,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
         process = AgenticProcess(name="test_process", key="test_key")
 
-        result = self.manager.create_process(self.project_id, process, automatic_publish=False)
+        result = self.manager.create_process(process, automatic_publish=False)
 
         mock_create_process.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -287,7 +287,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
         process = AgenticProcess(id=self.process_id, name="test_process", key="test_key")
 
-        result = self.manager.update_process(self.project_id, process, automatic_publish=False, upsert=False)
+        result = self.manager.update_process(process, automatic_publish=False, upsert=False)
 
         mock_update_process.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -299,7 +299,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_process.return_value = {"data": "test_data"}
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
 
-        result = self.manager.get_process(self.project_id, process_id=self.process_id, filter_settings=self.filter_settings)
+        result = self.manager.get_process(process_id=self.process_id, filter_settings=self.filter_settings)
 
         mock_get_process.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -311,7 +311,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_processes.return_value = {"data": "test_data"}
         mock_map_to_process_list.return_value = AgenticProcessList(processes=[])
 
-        result = self.manager.list_processes(self.project_id, self.filter_settings)
+        result = self.manager.list_processes(self.filter_settings)
 
         mock_list_processes.assert_called_once()
         mock_map_to_process_list.assert_called_once_with({"data": "test_data"})
@@ -323,7 +323,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_instances.return_value = {"data": "test_data"}
         mock_map_to_instance_list.return_value = ProcessInstanceList(instances=[])
 
-        result = self.manager.list_process_instances(self.project_id, self.process_id, self.filter_settings)
+        result = self.manager.list_process_instances(self.process_id, self.filter_settings)
 
         mock_list_instances.assert_called_once()
         mock_map_to_instance_list.assert_called_once_with({"data": "test_data"})
@@ -335,7 +335,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_process.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_process(self.project_id, process_id=self.process_id)
+        result = self.manager.delete_process(process_id=self.process_id)
 
         mock_delete_process.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -347,7 +347,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_process_revision.return_value = {"data": "test_data"}
         mock_map_to_process.return_value = AgenticProcess(id=self.process_id, name="test_process")
 
-        result = self.manager.publish_process_revision(self.project_id, process_id=self.process_id, revision=self.revision)
+        result = self.manager.publish_process_revision(process_id=self.process_id, revision=self.revision)
 
         mock_publish_process_revision.assert_called_once()
         mock_map_to_process.assert_called_once_with({"data": "test_data"})
@@ -360,7 +360,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
         task = Task(name="test_task")
 
-        result = self.manager.create_task(self.project_id, task, automatic_publish=False)
+        result = self.manager.create_task(task, automatic_publish=False)
 
         mock_create_task.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -372,7 +372,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_task.return_value = {"data": "test_data"}
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
 
-        result = self.manager.get_task(self.project_id, task_id=self.task_id)
+        result = self.manager.get_task(task_id=self.task_id)
 
         mock_get_task.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -384,7 +384,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_tasks.return_value = {"data": "test_data"}
         mock_map_to_task_list.return_value = TaskList(tasks=[])
 
-        result = self.manager.list_tasks(self.project_id, self.filter_settings)
+        result = self.manager.list_tasks(self.filter_settings)
 
         mock_list_tasks.assert_called_once()
         mock_map_to_task_list.assert_called_once_with({"data": "test_data"})
@@ -397,7 +397,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
         task = Task(id=self.task_id, name="test_task")
 
-        result = self.manager.update_task(self.project_id, task, automatic_publish=False, upsert=False)
+        result = self.manager.update_task(task, automatic_publish=False, upsert=False)
 
         mock_update_task.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -409,7 +409,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_task.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_task(self.project_id, task_id=self.task_id)
+        result = self.manager.delete_task(task_id=self.task_id)
 
         mock_delete_task.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -421,7 +421,7 @@ class TestAILabManager(unittest.TestCase):
         mock_publish_task_revision.return_value = {"data": "test_data"}
         mock_map_to_task.return_value = Task(id=self.task_id, name="test_task")
 
-        result = self.manager.publish_task_revision(self.project_id, task_id=self.task_id, revision=self.revision)
+        result = self.manager.publish_task_revision(task_id=self.task_id, revision=self.revision)
 
         mock_publish_task_revision.assert_called_once()
         mock_map_to_task.assert_called_once_with({"data": "test_data"})
@@ -433,7 +433,7 @@ class TestAILabManager(unittest.TestCase):
         mock_start_instance.return_value = {"data": "test_data"}
         mock_map_to_instance.return_value = ProcessInstance(id=self.instance_id, subject="test_subject", process=AgenticProcess(name="test_process"))
 
-        result = self.manager.start_instance(self.project_id, "test_process", subject="test_subject", variables=VariableList())
+        result = self.manager.start_instance("test_process", subject="test_subject", variables=VariableList())
 
         mock_start_instance.assert_called_once()
         mock_map_to_instance.assert_called_once_with({"data": "test_data"})
@@ -445,7 +445,7 @@ class TestAILabManager(unittest.TestCase):
         mock_abort_instance.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.abort_instance(self.project_id, self.instance_id)
+        result = self.manager.abort_instance(self.instance_id)
 
         mock_abort_instance.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -457,7 +457,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_instance.return_value = {"data": "test_data"}
         mock_map_to_instance.return_value = ProcessInstance(id=self.instance_id, subject="test_subject", process=AgenticProcess(name="test_process"))
 
-        result = self.manager.get_instance(self.project_id, self.instance_id)
+        result = self.manager.get_instance(self.instance_id)
 
         mock_get_instance.assert_called_once()
         mock_map_to_instance.assert_called_once_with({"data": "test_data"})
@@ -467,7 +467,7 @@ class TestAILabManager(unittest.TestCase):
     def test_get_instance_history_success(self, mock_get_instance_history):
         mock_get_instance_history.return_value = {"history": "test_history"}
 
-        result = self.manager.get_instance_history(self.project_id, self.instance_id)
+        result = self.manager.get_instance_history(self.instance_id)
 
         mock_get_instance_history.assert_called_once()
         self.assertIsInstance(result, dict)
@@ -476,7 +476,7 @@ class TestAILabManager(unittest.TestCase):
     def test_get_thread_information_success(self, mock_get_thread_information):
         mock_get_thread_information.return_value = {"info": "test_info"}
 
-        result = self.manager.get_thread_information(self.project_id, "test_thread")
+        result = self.manager.get_thread_information("test_thread")
 
         mock_get_thread_information.assert_called_once()
         self.assertIsInstance(result, dict)
@@ -487,7 +487,7 @@ class TestAILabManager(unittest.TestCase):
         mock_send_user_signal.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.send_user_signal(self.project_id, self.instance_id, "test_signal")
+        result = self.manager.send_user_signal(self.instance_id, "test_signal")
 
         mock_send_user_signal.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -500,7 +500,7 @@ class TestAILabManager(unittest.TestCase):
         mock_map_to_kb.return_value = KnowledgeBase(id=self.kb_id, name="test_kb")
         kb = KnowledgeBase(name="test_kb")
 
-        result = self.manager.create_knowledge_base(self.project_id, kb)
+        result = self.manager.create_knowledge_base(kb)
 
         mock_create_kb.assert_called_once()
         mock_map_to_kb.assert_called_once_with({"data": "test_data"})
@@ -512,7 +512,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_kbs.return_value = {"data": "test_data"}
         mock_map_to_kb_list.return_value = KnowledgeBaseList(knowledge_bases=[])
 
-        result = self.manager.list_knowledge_bases(self.project_id, start=0, count=10)
+        result = self.manager.list_knowledge_bases(start=0, count=10)
 
         mock_list_kbs.assert_called_once()
         mock_map_to_kb_list.assert_called_once_with({"data": "test_data"})
@@ -524,7 +524,7 @@ class TestAILabManager(unittest.TestCase):
         mock_get_kb.return_value = {"data": "test_data"}
         mock_map_to_kb.return_value = KnowledgeBase(id=self.kb_id, name="test_kb")
 
-        result = self.manager.get_knowledge_base(self.project_id, kb_id=self.kb_id)
+        result = self.manager.get_knowledge_base(kb_id=self.kb_id)
 
         mock_get_kb.assert_called_once()
         mock_map_to_kb.assert_called_once_with({"data": "test_data"})
@@ -536,7 +536,7 @@ class TestAILabManager(unittest.TestCase):
         mock_delete_kb.return_value = {"data": "test_data"}
         mock_map_to_empty_response.return_value = {"status": "success"}
 
-        result = self.manager.delete_knowledge_base(self.project_id, kb_id=self.kb_id)
+        result = self.manager.delete_knowledge_base(kb_id=self.kb_id)
 
         mock_delete_kb.assert_called_once()
         mock_map_to_empty_response.assert_called_once()
@@ -548,7 +548,7 @@ class TestAILabManager(unittest.TestCase):
         mock_list_jobs.return_value = {"data": "test_data"}
         mock_map_to_job_list.return_value = JobList(jobs=[])
 
-        result = self.manager.list_jobs(self.project_id, self.filter_settings)
+        result = self.manager.list_jobs(self.filter_settings)
 
         mock_list_jobs.assert_called_once()
         mock_map_to_job_list.assert_called_once_with({"data": "test_data"})