pygeai 0.4.0b12__py3-none-any.whl → 0.5.0__py3-none-any.whl

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(alias="beta")
+        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

@@ -2,8 +2,7 @@ from unittest import TestCase
 import uuid
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Tool, ToolParameter
-from pydantic import ValidationError
-from pygeai.core.common.exceptions import APIError 
+from pygeai.core.common.exceptions import APIResponseError
 
 
 class TestAILabCreateToolIntegration(TestCase):    
@@ -94,15 +93,12 @@ class TestAILabCreateToolIntegration(TestCase):
 
         for auto_publish in test_params:
             
-            with self.subTest(input=auto_publish):     
-                with self.assertRaises(ValidationError) as context:
-                    self.new_tool = Tool(
+            with self.subTest(input=auto_publish): 
+                self.new_tool = Tool(
                         name=str(uuid.uuid4())
                     )
-                    self.__create_tool(automatic_publish=auto_publish)
-
-                self.assertIn("description", str(context.exception))
-                self.assertIn("Field required", str(context.exception))
+                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):
@@ -111,7 +107,7 @@ class TestAILabCreateToolIntegration(TestCase):
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
                 self.new_tool.name = ""
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
 
                 self.assertIn(
@@ -128,7 +124,7 @@ class TestAILabCreateToolIntegration(TestCase):
 
             with self.subTest(input=auto_publish):
                 self.new_tool.name = "sdk_project_gemini_tool"
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Tool already exists [name=sdk_project_gemini_tool]..",
@@ -145,7 +141,7 @@ class TestAILabCreateToolIntegration(TestCase):
                 new_tool = self.__load_tool()
                 new_tool2 = self.__load_tool()
 
-                with self.assertRaises(APIError) as exception:
+                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(
@@ -154,7 +150,7 @@ class TestAILabCreateToolIntegration(TestCase):
                     f"Expected an error about invalid character (:) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
-                with self.assertRaises(APIError) as exception:
+                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(
@@ -190,7 +186,7 @@ class TestAILabCreateToolIntegration(TestCase):
             with self.subTest(input=auto_publish):
                 self.new_tool.access_scope = "public"
                 self.new_tool.public_name = None
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Tool publicName is required for tools with accessScope=public.",
@@ -206,7 +202,7 @@ class TestAILabCreateToolIntegration(TestCase):
             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(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
 
                 self.assertIn(
@@ -232,7 +228,7 @@ class TestAILabCreateToolIntegration(TestCase):
                 duplicated_pn_tool.access_scope = "public"
                 duplicated_pn_tool.public_name = self.created_tool.public_name
                 
-                with self.assertRaises(APIError) as exception:
+                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}].",

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

@@ -1,8 +1,8 @@
 from unittest import TestCase
 import uuid
 from pygeai.lab.managers import AILabManager
-from pygeai.lab.models import Tool, AgentData, Prompt, LlmConfig, Model
-from pygeai.core.common.exceptions import MissingRequirementException, InvalidAPIResponseException
+from pygeai.lab.models import Tool
+from pygeai.core.common.exceptions import APIResponseError, MissingRequirementException, InvalidAPIResponseException
 
 ai_lab_manager: AILabManager
 
@@ -66,7 +66,7 @@ class TestAILabDeleteToolIntegration(TestCase):
     def test_delete_tool_invalid_id_valid_name(self):
         invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
         created_tool = self.__create_tool() 
-        with self.assertRaises(InvalidAPIResponseException) as exception:
+        with self.assertRaises(APIResponseError) as exception:
             self.__delete_tool(tool_name=created_tool.name, tool_id=invalid_id)
 
         self.assertIn(

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

@@ -2,7 +2,7 @@ from unittest import TestCase
 import unittest
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Tool, FilterSettings
-from pygeai.core.common.exceptions import APIError
+from pygeai.core.common.exceptions import APIResponseError
 import copy
 
 ai_lab_manager: AILabManager
@@ -36,7 +36,7 @@ class TestAILabGetToolIntegration(TestCase):
     
     def test_get_tool_invalid_tool_id(self):
         invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
-        with self.assertRaises(APIError) as context:
+        with self.assertRaises(APIResponseError) as context:
             self.__get_tool(tool_id=invalid_id)
         self.assertIn(
             f"Tool not found [IdOrName= {invalid_id}].",
@@ -65,7 +65,7 @@ class TestAILabGetToolIntegration(TestCase):
     def test_get_tool_by_earlier_revision(self):
         filter_settings = copy.deepcopy(self.filter_settings)
         filter_settings.revision = "2"
-        with self.assertRaises(APIError) as context:
+        with self.assertRaises(APIResponseError) as context:
             self.__get_tool(filter_settings=filter_settings)
         self.assertIn(
             f"Requested revision not found [revision={filter_settings.revision}].",

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

@@ -1,6 +1,6 @@
 from unittest import TestCase
 import uuid
-from pygeai.core.common.exceptions import APIError
+from pygeai.core.common.exceptions import APIResponseError
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Tool, ToolParameter
 
@@ -65,7 +65,7 @@ class TestAILabUpdateToolIntegration(TestCase):
                 tool = self.__load_tool()
                 tool2 = self.__load_tool()
 
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     tool.name = f"{tool.name}:invalid"
                     self.__update_tool(tool=tool, automatic_publish=auto_publish)
                 self.assertIn(
@@ -74,7 +74,7 @@ class TestAILabUpdateToolIntegration(TestCase):
                     f"Expected an error about invalid character (:) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     tool2.name = f"{tool2.name}/invalid"
                     self.__update_tool(tool=tool2, automatic_publish=auto_publish)
                 self.assertIn(
@@ -91,7 +91,7 @@ class TestAILabUpdateToolIntegration(TestCase):
 
             with self.subTest(input=auto_publish):
                 self.tool_to_update.name = "sdk_project_gemini_tool"
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__update_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Tool already exists",
@@ -107,7 +107,7 @@ class TestAILabUpdateToolIntegration(TestCase):
 
             with self.subTest(input=auto_publish):
                 self.tool_to_update.name = ""
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__update_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Tool name cannot be empty",
@@ -123,7 +123,7 @@ class TestAILabUpdateToolIntegration(TestCase):
             with self.subTest(input=auto_publish):
                 invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
                 self.tool_to_update.id = invalid_id
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__update_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     f"Tool not found [IdOrName= {invalid_id}",
@@ -172,7 +172,7 @@ class TestAILabUpdateToolIntegration(TestCase):
         self.tool_to_update.public_name = "invalid#name"
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):                
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__update_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.",
@@ -219,7 +219,7 @@ class TestAILabUpdateToolIntegration(TestCase):
 
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):  
-                with self.assertRaises(APIError) as exc:
+                with self.assertRaises(APIResponseError) as exc:
                     self.__update_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Either openApi (URL with the OpenAPI definition) or the openApiJson (with the conent) are required for api-tools.",
@@ -245,7 +245,6 @@ class TestAILabUpdateToolIntegration(TestCase):
 
    
     def test_update_tool_upsert(self):
-        print(self.tool_to_update)
         self.tool_to_update.id = str(uuid.uuid4())
         self.tool_to_update.name = str(uuid.uuid4())
         result = self.__update_tool(upsert=True)

pygeai/tests/snippets/lab/agentic_flow_example_4.py

@@ -22,23 +22,23 @@ def rollback():
     print("\n=== Initiating Rollback ===")
     if created_entities["instance_id"]:
         print(f"Deleting instance {created_entities['instance_id']}...")
-        result = manager.abort_instance(project_id=project_id, instance_id=created_entities["instance_id"])
+        result = manager.abort_instance(instance_id=created_entities["instance_id"])
         print(f"Rollback: {result}")
     if created_entities["process_id"]:
         print(f"Deleting process {created_entities['process_id']}...")
-        result = manager.delete_process(project_id=project_id, process_id=created_entities["process_id"])
+        result = manager.delete_process(process_id=created_entities["process_id"])
         print(f"Rollback: {result}")
     if created_entities["task_id"]:
         print(f"Deleting task {created_entities['task_id']}...")
-        result = manager.delete_task(project_id=project_id, task_id=created_entities["task_id"])
+        result = manager.delete_task(task_id=created_entities["task_id"])
         print(f"Rollback: {result}")
     if created_entities["tool_id"]:
         print(f"Deleting tool {created_entities['tool_id']}...")
-        result = manager.delete_tool(project_id=project_id, tool_id=created_entities["tool_id"])
+        result = manager.delete_tool(tool_id=created_entities["tool_id"])
         print(f"Rollback: {result}")
     if created_entities["agent_id"]:
         print(f"Deleting agent {created_entities['agent_id']}...")
-        result = manager.delete_agent(project_id=project_id, agent_id=created_entities["agent_id"])
+        result = manager.delete_agent(agent_id=created_entities["agent_id"])
         print(f"Rollback: {result}")
     print("Rollback complete.")
 
@@ -82,7 +82,7 @@ def main():
         revision=1,
         status="pending"
     )
-    create_tool_result = manager.create_tool(project_id=project_id, tool=tool, automatic_publish=False)
+    create_tool_result = manager.create_tool(tool=tool, automatic_publish=False)
     if isinstance(create_tool_result, Tool):
         print(f"Success: Created Tool: {create_tool_result.name}, ID: {create_tool_result.id}")
         created_entities["tool_id"] = create_tool_result.id
@@ -107,7 +107,7 @@ def main():
             value="English"
         )
     )
-    update_tool_result = manager.update_tool(project_id=project_id, tool=tool, automatic_publish=False)
+    update_tool_result = manager.update_tool(tool=tool, automatic_publish=False)
     if isinstance(update_tool_result, Tool):
         print(f"Success: Updated Tool: {update_tool_result.description}")
     else:
@@ -116,7 +116,7 @@ def main():
         exit()
 
     print("Publishing tool revision '1'...")
-    publish_tool_result = manager.publish_tool_revision(project_id=project_id, tool_id=created_entities["tool_id"], revision="1")
+    publish_tool_result = manager.publish_tool_revision(tool_id=created_entities["tool_id"], revision="1")
     if isinstance(publish_tool_result, Tool):
         print(f"Success: Published Tool Revision: {publish_tool_result.name}")
     else:
@@ -125,7 +125,7 @@ def main():
         exit()
 
     print("Retrieving latest tool version...")
-    latest_tool = manager.get_tool(project_id=project_id, tool_id=created_entities["tool_id"])
+    latest_tool = manager.get_tool(tool_id=created_entities["tool_id"])
     if isinstance(latest_tool, Tool):
         print(f"Success: Latest Tool: {latest_tool.name}, Description: {latest_tool.description}")
     else:
@@ -184,7 +184,7 @@ def main():
         revision=1,
         status="pending"
     )
-    create_agent_result = manager.create_agent(project_id=project_id, agent=agent, automatic_publish=False)
+    create_agent_result = manager.create_agent(agent=agent, automatic_publish=False)
     if isinstance(create_agent_result, Agent):
         print(f"Success: Created Agent: {create_agent_result.name}, ID: {create_agent_result.id}")
         created_entities["agent_id"] = create_agent_result.id
@@ -200,7 +200,7 @@ def main():
     agent.description = "Improved agent for text summarization tasks"
     agent.job_description = "Summarizes text and extracts key insights"
 
-    update_agent_result = manager.update_agent(project_id=project_id, agent=agent, automatic_publish=False)
+    update_agent_result = manager.update_agent(agent=agent, automatic_publish=False)
     if isinstance(update_agent_result, Agent):
         print(f"Success: Updated Agent: {update_agent_result.description}")
     else:
@@ -209,7 +209,7 @@ def main():
         exit()
 
     print("Publishing agent revision '1'...")
-    publish_agent_result = manager.publish_agent_revision(project_id=project_id, agent_id=created_entities["agent_id"], revision="1")
+    publish_agent_result = manager.publish_agent_revision(agent_id=created_entities["agent_id"], revision="1")
     if isinstance(publish_agent_result, Agent):
         print(f"Success: Published Agent Revision: {publish_agent_result.name}")
     else:
@@ -218,7 +218,7 @@ def main():
         exit()
 
     print("Retrieving latest agent version...")
-    latest_agent = manager.get_agent(project_id=project_id, agent_id=created_entities["agent_id"])
+    latest_agent = manager.get_agent(agent_id=created_entities["agent_id"])
     if isinstance(latest_agent, Agent):
         print(f"Success: Latest Agent: {latest_agent.name}, Description: {latest_agent.description}")
     else:
@@ -259,7 +259,7 @@ def main():
         revision=1,
         status="pending"
     )
-    create_task_result = manager.create_task(project_id=project_id, task=task, automatic_publish=False)
+    create_task_result = manager.create_task(task=task, automatic_publish=False)
     if isinstance(create_task_result, Task):
         print(f"Success: Created Task: {create_task_result.name}, ID: {create_task_result.id}")
         created_entities["task_id"] = create_task_result.id
@@ -275,7 +275,7 @@ def main():
     task.description = "Enhanced task for text summarization and analysis"
     task.prompt_data.instructions = "Summarize text and highlight key insights."
 
-    update_task_result = manager.update_task(project_id=project_id, task=task, automatic_publish=False)
+    update_task_result = manager.update_task(task=task, automatic_publish=False)
     if isinstance(update_task_result, Task):
         print(f"Success: Updated Task: {update_task_result.description}")
     else:
@@ -284,7 +284,7 @@ def main():
         exit()
 
     print("Publishing task revision '1'...")
-    publish_task_result = manager.publish_task_revision(project_id=project_id, task_id=created_entities["task_id"], revision="1")
+    publish_task_result = manager.publish_task_revision(task_id=created_entities["task_id"], revision="1")
     if isinstance(publish_task_result, Task):
         print(f"Success: Published Task Revision: {publish_task_result.name}")
     else:
@@ -293,7 +293,7 @@ def main():
         exit()
 
     print("Retrieving latest task version...")
-    latest_task = manager.get_task(project_id=project_id, task_id=created_entities["task_id"])
+    latest_task = manager.get_task(task_id=created_entities["task_id"])
     if isinstance(latest_task, Task):
         print(f"Success: Latest Task: {latest_task.name}, Description: {latest_task.description}")
     else:
@@ -358,7 +358,7 @@ def main():
         revision=1,
         status="pending"
     )
-    create_process_result = manager.create_process(project_id=project_id, process=process, automatic_publish=False)
+    create_process_result = manager.create_process(process=process, automatic_publish=False)
     if isinstance(create_process_result, AgenticProcess):
         print(f"Success: Created Process: {create_process_result.name}, ID: {create_process_result.id}")
         created_entities["process_id"] = create_process_result.id
@@ -373,7 +373,7 @@ def main():
     process.description = "Optimized process for text summarization workflows"
     process.agentic_activities[0].name = "Advanced Text Summarization"
 
-    update_process_result = manager.update_process(project_id=project_id, process=process, automatic_publish=False)
+    update_process_result = manager.update_process(process=process, automatic_publish=False)
     if isinstance(update_process_result, AgenticProcess):
         print(f"Success: Updated Process: {update_process_result.description}")
     else:
@@ -382,7 +382,7 @@ def main():
         exit()
 
     print("Publishing process revision '1'...")
-    publish_process_result = manager.publish_process_revision(project_id=project_id, process_id=created_entities["process_id"], revision="1")
+    publish_process_result = manager.publish_process_revision(process_id=created_entities["process_id"], revision="1")
     if isinstance(publish_process_result, AgenticProcess):
         print(f"Success: Published Process Revision: {publish_process_result.name}")
     else:
@@ -391,7 +391,7 @@ def main():
         exit()
 
     print("Retrieving latest process version...")
-    latest_process = manager.get_process(project_id=project_id, process_id=created_entities["process_id"])
+    latest_process = manager.get_process(process_id=created_entities["process_id"])
     if isinstance(latest_process, AgenticProcess):
         print(f"Success: Latest Process: {latest_process.name}, Description: {latest_process.description}")
     else:
@@ -417,7 +417,7 @@ def main():
         exit()
 
     print("Retrieving instance information...")
-    instance_info = manager.get_instance(project_id=project_id, instance_id=created_entities["instance_id"])
+    instance_info = manager.get_instance(instance_id=created_entities["instance_id"])
     if isinstance(instance_info, ProcessInstance):
         print(f"Success: Instance Info: Process: {instance_info.process.name}, Subject: {instance_info.subject}")
     else:
@@ -426,7 +426,7 @@ def main():
         exit()
 
     print("Retrieving instance history...")
-    history = manager.get_instance_history(project_id=project_id, instance_id=created_entities["instance_id"])
+    history = manager.get_instance_history(instance_id=created_entities["instance_id"])
     if isinstance(history, dict):
         print(f"Success: Instance History: {history}")
     else:

pygeai/tests/snippets/lab/samples/summarize_files.py

@@ -31,7 +31,7 @@ def rollback():
     print("\n=== Initiating Rollback ===")
     if created_entities["agent_id"]:
         print(f"Deleting agent {created_entities['agent_id']}...")
-        result = lab_manager.delete_agent(project_id=project_id, agent_id=created_entities["agent_id"])
+        result = lab_manager.delete_agent(agent_id=created_entities["agent_id"])
         print(f"Rollback: {result}")
     if created_entities["file_id"]:
         print(f"Deleting file {created_entities['file_id']}...")
@@ -107,7 +107,7 @@ def main():
         revision=1,
         status="pending"
     )
-    create_agent_result = lab_manager.create_agent(project_id=project_id, agent=agent, automatic_publish=False)
+    create_agent_result = lab_manager.create_agent(agent=agent, automatic_publish=False)
     if isinstance(create_agent_result, Agent):
         print(f"Success: Created Agent: {create_agent_result.name}, ID: {create_agent_result.id}")
         created_entities["agent_id"] = create_agent_result.id
@@ -117,7 +117,7 @@ def main():
         exit()
 
     print("Publishing agent revision '1'...")
-    publish_agent_result = lab_manager.publish_agent_revision(project_id=project_id, agent_id=created_entities["agent_id"], revision="1")
+    publish_agent_result = lab_manager.publish_agent_revision(agent_id=created_entities["agent_id"], revision="1")
     if isinstance(publish_agent_result, Agent):
         print(f"Success: Published Agent Revision: {publish_agent_result.name}")
     else:

pygeai/tests/snippets/lab/use_cases/file_summarizer_example.py

@@ -27,7 +27,7 @@ def rollback():
     print("\n=== Initiating Rollback ===")
     if created_entities["agent_id"]:
         print(f"Deleting agent {created_entities['agent_id']}...")
-        result = lab_manager.delete_agent(project_id=project_id, agent_id=created_entities["agent_id"])
+        result = lab_manager.delete_agent(agent_id=created_entities["agent_id"])
         print(f"Rollback: {result}")
     if created_entities["file_id"]:
         print(f"Deleting file {created_entities['file_id']}...")
@@ -102,7 +102,7 @@ def main():
         revision=1,
         status="pending"
     )
-    create_agent_result = lab_manager.create_agent(project_id=project_id, agent=agent, automatic_publish=False)
+    create_agent_result = lab_manager.create_agent(agent=agent, automatic_publish=False)
     if isinstance(create_agent_result, Agent):
         print(f"Success: Created Agent: {create_agent_result.name}, ID: {create_agent_result.id}")
         created_entities["agent_id"] = create_agent_result.id
@@ -112,7 +112,7 @@ def main():
         exit()
 
     print("Publishing agent revision '1'...")
-    publish_agent_result = lab_manager.publish_agent_revision(project_id=project_id, agent_id=created_entities["agent_id"], revision="1")
+    publish_agent_result = lab_manager.publish_agent_revision(agent_id=created_entities["agent_id"], revision="1")
     if isinstance(publish_agent_result, Agent):
         print(f"Success: Published Agent Revision: {publish_agent_result.name}")
     else: