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

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

@@ -0,0 +1,267 @@
+from unittest import TestCase
+import uuid
+from pygeai.core.common.exceptions import APIResponseError
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Tool, ToolParameter
+
+
+class TestAILabUpdateToolIntegration(TestCase):  
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.tool_to_update = self.__load_tool()
+
+    
+    def __load_tool(self):
+        self.random_str = str(uuid.uuid4())
+        return Tool(
+            id="c77e1f2e-0322-4dd0-b6ec-aff217f1cb32",
+            name=f"sdk_project_updated_tool_{self.random_str}",
+            description=f"Tool updated for sdk testing purposes {self.random_str}",
+            scope="builtin",
+            openApi="https://raw.usercontent.com//openapi.json",
+            openApiJson={"openapi": "3.0.0","info": {"title": f"Simple API overview {self.random_str}","version": "3.0.0"}},
+            accessScope="private",
+            reportEvents="None",
+            parameters=[{
+                "key": "param", 
+                "description": f"param description {self.random_str}",
+                "type":"app", 
+                "value": f"value {self.random_str}",
+                "data_type": "String",
+                "isRequired": False
+            }]
+        )
+    
+
+    def __update_tool(self, tool: Tool = None, automatic_publish: bool = False, upsert: bool = False):
+        """
+        Helper method to update a tool.
+        """
+        return self.ai_lab_manager.update_tool(
+            tool = self.tool_to_update if tool is None else tool,
+            automatic_publish=automatic_publish,
+            upsert=upsert
+        )
+
+
+    def test_update_tool_all_fields_success(self):
+        updated_tool = self.__update_tool()
+        self.assertEqual(updated_tool.name, self.tool_to_update.name)
+        self.assertEqual(updated_tool.description, self.tool_to_update.description)
+        self.assertEqual(updated_tool.open_api_json, self.tool_to_update.open_api_json)
+        self.assertEqual(updated_tool.parameters[0].description, self.tool_to_update.parameters[0].description)
+        self.assertEqual(updated_tool.parameters[0].value, self.tool_to_update.parameters[0].value)
+        self.assertTrue(updated_tool.is_draft, "Expected tool to be in draft state after update")
+
+
+    def test_update_tool_invalid_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                tool = self.__load_tool()
+                tool2 = self.__load_tool()
+
+                with self.assertRaises(APIResponseError) as exception:
+                    tool.name = f"{tool.name}:invalid"
+                    self.__update_tool(tool=tool, automatic_publish=auto_publish)
+                self.assertIn(
+                    "Invalid character in name (: is not allowed).",
+                    str(exception.exception),                    
+                    f"Expected an error about invalid character (:) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+                with self.assertRaises(APIResponseError) as exception:
+                    tool2.name = f"{tool2.name}/invalid"
+                    self.__update_tool(tool=tool2, automatic_publish=auto_publish)
+                self.assertIn(
+                    "Invalid character in name (/ is not allowed).",
+                    str(exception.exception),                    
+                    f"Expected an error about invalid character (/) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_tool_duplicated_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+
+            with self.subTest(input=auto_publish):
+                self.tool_to_update.name = "sdk_project_gemini_tool"
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__update_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Tool already exists",
+                    str(exception.exception),                    
+                    f"Expected an error about duplicated tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_tool_no_name(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+
+            with self.subTest(input=auto_publish):
+                self.tool_to_update.name = ""
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__update_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Tool name cannot be empty",
+                    str(exception.exception),                    
+                    f"Expected an error when tool name is not provided with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_tool_invalid_id(self):
+        test_params = [ True, False ]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+                self.tool_to_update.id = invalid_id
+                with self.assertRaises(APIResponseError) as exception:
+                    self.__update_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    f"Tool not found [IdOrName= {invalid_id}",
+                    str(exception.exception),                    
+                    f"Expected an error when tool id is invalid and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_tool_scope(self):
+        for scope in ["builtin", "external", "api"]:
+            tool = self.__load_tool()
+            tool.scope = scope
+            result = self.__update_tool(tool=tool)
+            self.assertEqual(result.scope, scope)
+
+        
+    def test_update_tool_invalid_scope(self):
+        test_params = [ True, False ]
+        self.tool_to_update.scope = "project"
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):                
+                with self.assertRaises(ValueError) as exception:
+                    self.__update_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    f"Scope must be one of builtin, external, api, proxied",
+                    str(exception.exception),                    
+                    f"Expected an error when tool scope is invalid and autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_tool_access_scope(self):
+        for access_scope in ["public", "private"]:
+            tool = self.__load_tool()
+            tool.access_scope = access_scope
+
+            if access_scope == "public":
+                tool.public_name = f"com.sdk.testing.{self.random_str}"
+
+            updated_tool = self.__update_tool(tool=tool)
+            self.assertEqual(updated_tool.access_scope, access_scope)
+
+
+    def test_update_tool_invalid_public_name(self):
+        test_params = [ True, False ]
+        self.tool_to_update.access_scope = "public"
+        self.tool_to_update.public_name = "invalid#name"
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):                
+                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.",
+                    str(exception.exception),                    
+                    f"Expected error when invalid public name is sent and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    def test_update_tool_duplicate_public_name(self):
+        test_params = [ True, False ]
+        self.tool_to_update.access_scope = "public"
+        self.tool_to_update.public_name = "test.sdk.beta.tool"
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):   
+                with self.assertRaises(Exception) as exc:
+                    self.__update_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Tool already exists",
+                    str(exc.exception),
+                    f"Expected error when public name is duplicated and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_tool_no_public_name(self):
+        test_params = [ True, False ]
+        self.tool_to_update.access_scope = "public"
+        self.tool_to_update.public_name = ""
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):  
+                with self.assertRaises(Exception) as exc:
+                    self.__update_tool(automatic_publish=auto_publish)
+                self.assertIn(
+                    "Tool publicName is required for tools with accessScope=public.",
+                    str(exc.exception),
+                    f"Expected error when public name is not provided and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+   
+
+    def test_update_tool_no_open_api_nor_json(self):
+        test_params = [ True, False ]
+        self.tool_to_update.scope = "api"
+        self.tool_to_update.open_api = ""
+        self.tool_to_update.open_api_json = None
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):  
+                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.",
+                    str(exc.exception),
+                    f"Expected error when no openApi or openApiJson are provided and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_update_tool_parameters(self):
+        self.tool_to_update.parameters = [
+            ToolParameter(key="paramA", data_type="String", description="descA", is_required=True),
+            ToolParameter(key="paramB", data_type="String", description="descB", is_required=False)
+        ]
+        result = self.__update_tool()
+        self.assertEqual(len(result.parameters), 2)
+        self.assertEqual(result.parameters[0].key, "paramA")
+        self.assertEqual(result.parameters[1].key, "paramB")
+
+
+    def test_update_tool_automatic_publish(self):
+        result = self.__update_tool(automatic_publish=True)
+        self.assertFalse(result.is_draft, "Expected tool to be published after update with automatic_publish=True")
+
+   
+    def test_update_tool_upsert(self):
+        self.tool_to_update.id = str(uuid.uuid4())
+        self.tool_to_update.name = str(uuid.uuid4())
+        result = self.__update_tool(upsert=True)
+
+        if isinstance(result, Tool):
+            self.ai_lab_manager.delete_tool(result.id)
+
+        self.assertEqual(result.name,  self.tool_to_update.name)
+
+
+    def test_update_tool_upsert_false_not_exists(self):
+        new_id = str(uuid.uuid4())
+        self.tool_to_update.id = new_id
+        with self.assertRaises(Exception) as exc:
+            self.__update_tool(upsert=False)
+        self.assertIn(f"Tool not found [IdOrName= {new_id}]", str(exc.exception))
+
+    
+    
+    

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/agents/get_sharing_link.py

@@ -10,5 +10,4 @@ result = manager.create_sharing_link(
 
 
 print(f"Sharing link created for agent ID: {result.agent_id}")
-print(f"API Token: {result.api_token}")
-print(f"Shared Link: {result.shared_link}")
+print(f"Shared Link: {result.shared_link}")

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/tools/create_tool.py

@@ -28,7 +28,7 @@ parameters = [
 ]
 
 tool = Tool(
-    name="sample_tool_v5",
+    name="sample_tool_v7",
     description="a builtin tool that does something but really does nothing cos it does not exist.",
     scope="builtin",
     parameters=parameters

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:

pygeai/tests/snippets/lab/use_cases/file_summarizer_example_2.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']}...")
@@ -37,8 +37,8 @@ def rollback():
 
 
 def main():
-    # File Upload Flow
-    print("\n=== File Upload Flow ===")
+    # File Upload Step
+    print("\n=== File Upload Step ===")
     print("Uploading file 'test.txt'...")
     file_to_upload = UploadFile(
         name="test.txt",
@@ -65,8 +65,8 @@ def main():
         rollback()
         exit()
 
-    # Agent Flow
-    print("\n=== Agent Flow ===")
+    # Agent Step
+    print("\n=== Agent Step ===")
     print("Creating agent 'FileSummaryAgent2' as draft...")
     agent_id = str(uuid4())
     agent = Agent(
@@ -95,14 +95,14 @@ def main():
                 sampling=Sampling(temperature=0.8)
             ),
             models=ModelList(models=[
-                Model(name="vertex_ai/gemini-1.5-pro")
+                Model(name="openai/gpt-4o")
             ])
         ),
         is_draft=True,
         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:
@@ -120,8 +120,8 @@ def main():
         rollback()
         exit()
 
-    # Chat Completion Flow
-    print("\n=== Chat Completion Flow ===")
+    # Chat Completion Step
+    print("\n=== Chat Completion Step ===")
     print(f"Asking agent about the uploaded file '{file_name}'...")
     messages = ChatMessageList(messages=[
         ChatMessage(
@@ -154,4 +154,4 @@ if __name__ == "__main__":
         rollback()
     except Exception as e:
         rollback()
-        print(f"\n# Critical error: {e}")
+        print(f"\n# Critical error: {e}")

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

@@ -185,7 +185,6 @@ WEB_READING_GUIDE:
 # Update the agent
 manager = AILabManager()
 result = manager.update_agent(
-    project_id="2ca6883f-6778-40bb-bcc1-85451fb11107",
     agent=agent,
     automatic_publish=True
 )
@@ -193,4 +192,4 @@ result = manager.update_agent(
 if isinstance(result, Agent):
     print(f"Agent updated successfully: {agent.to_dict()}")
 else:
-    print("Errors:", result.errors if hasattr(result, 'errors') else "Unknown error occurred")
+    print("Errors:", result.errors if hasattr(result, 'errors') else "Unknown error occurred")