pygeai 0.4.0b2__py3-none-any.whl → 0.4.0b4__py3-none-any.whl

pygeai/assistant/rag/models.py

@@ -227,7 +227,7 @@ class SearchOptions(CustomBaseModel):
             "ingestion": self.ingestion.to_dict() if self.ingestion else None,
             "options": self.options,
             "rerank": self.rerank,
-            "variables": self.variables.to_dict() if self.variables else None,
+            "variables": self.variables.to_list() if self.variables else None,
             "vectorStore": self.vector_store
         }
         return {k: v for k, v in result.items() if v is not None}

pygeai/lab/models.py

@@ -94,7 +94,7 @@ class Model(CustomBaseModel):
     :param llm_config: Optional[LlmConfig] - Overrides default agent LLM settings.
     :param prompt: Optional[dict] - A tailored prompt specific to this model.
     """
-    name: str = Field(..., alias="name")
+    name: Optional[str] = Field(None, alias="name")
     llm_config: Optional[LlmConfig] = Field(None, alias="llmConfig")
     prompt: Optional[Dict[str, Any]] = Field(None, alias="prompt")
 
@@ -161,12 +161,13 @@ class Prompt(CustomBaseModel):
     :param context: Optional[str] - Background context for the agent # NOT IMPLEMENTED YET
     :param examples: List[PromptExample] - List of example input-output pairs.
     """
-    instructions: str = Field(..., alias="instructions")
+    instructions: Optional[str] = Field(None, alias="instructions")
     inputs: Optional[List[str]] = Field(None, alias="inputs")
     outputs: Optional[List[PromptOutput]] = Field([], alias="outputs")
     context: Optional[str] = Field(None, alias="context", description="Background context for the agent")
     examples: Optional[List[PromptExample]] = Field(None, alias="examples")
 
+    '''
     @field_validator("instructions")
     @classmethod
     def validate_instructions(cls, value: str) -> str:
@@ -174,6 +175,7 @@ class Prompt(CustomBaseModel):
             raise ValueError("instructions cannot be blank")
 
         return value
+    '''
 
     @field_validator("outputs", mode="before")
     @classmethod
@@ -687,7 +689,7 @@ class Tool(CustomBaseModel):
     :param status: Optional[str] - Current status of the tool (e.g., "active"), defaults to None.
     """
     name: str = Field(..., alias="name", description="The name of the tool")
-    description: str = Field(..., alias="description", description="Description of the tool's purpose")
+    description: Optional[str] = Field(None, alias="description", description="Description of the tool's purpose")
     scope: str = Field("builtin", alias="scope", description="The scope of the tool (e.g., 'builtin', 'external', 'api')")
     parameters: Optional[List[ToolParameter]] = Field(None, alias="parameters", description="List of parameters required by the tool")
     access_scope: Optional[str] = Field(None, alias="accessScope", description="The access scope of the tool ('public' or 'private')")
@@ -730,6 +732,7 @@ class Tool(CustomBaseModel):
             raise ValueError("public_name is required if access_scope is 'public'")
         return self
 
+    '''
     @model_validator(mode="after")
     def validate_api_tool_requirements(self):
         if self.scope == "api" and not (self.open_api or self.open_api_json):
@@ -739,6 +742,7 @@ class Tool(CustomBaseModel):
             if len(param_keys) != len(set(param_keys)):
                 raise ValueError("All parameter keys must be unique within the tool")
         return self
+    '''
 
     @field_validator("parameters", mode="before")
     @classmethod

pygeai/lab/processes/mappers.py

@@ -110,8 +110,8 @@ class AgenticProcessMapper:
         """
         return [
             Variable(
-                key=var["key"],
-                value=var["value"]
+                key=var.get("key"),
+                value=var.get("value")
             )
             for var in data
         ]

pygeai/lab/tools/mappers.py

@@ -37,8 +37,8 @@ class ToolMapper:
         """
         return [
             ToolMessage(
-                description=msg["description"],
-                type=msg["type"]
+                description=msg.get("description"),
+                type=msg.get("type")
             )
             for msg in messages_data
         ]
@@ -55,9 +55,9 @@ class ToolMapper:
         """
         tool_data = data.get("tool", data)
 
-        name = tool_data["name"]
-        description = tool_data["description"]
-        scope = tool_data["scope"]
+        name = tool_data.get("name")
+        description = tool_data.get("description")
+        scope = tool_data.get("scope")
         parameter_data = tool_data.get("parameters")
         parameters = cls._map_parameters(parameter_data) if parameter_data else None
 

pygeai/tests/integration/chat/test_generate_image.py

@@ -0,0 +1,162 @@
+from unittest import TestCase
+from pygeai.chat.clients import ChatClient
+
+chat_client: ChatClient
+
+class TestChatGenerateImageIntegration(TestCase):    
+
+    def setUp(self):
+        self.chat_client = ChatClient(alias="beta")
+        self.new_image = self.__load_image()
+
+
+    def __load_image(self):
+        return {
+            "model": "openai/gpt-image-1",
+            "prompt": "generate an image of a futuristic city skyline at sunset",
+            "n": 1,
+            "quality": "high",
+            "size": "1024x1536"
+        }
+    
+
+    def __generate_image(self, image = None):
+        image = image if image is not None else self.new_image
+        return self.chat_client.generate_image(
+            model=image["model"],
+            prompt=image["prompt"],
+            n=image["n"],
+            quality=image["quality"],
+            size=image["size"],
+            aspect_ratio= image["aspect_ratio"] if "aspect_ratio" in image else None
+        )
+
+    
+    def test_generate_image(self):
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 1, "Expected an image to be generated")
+
+
+    def test_generate_image_invalid_model(self):
+        self.new_image["model"] = "openai/gpt-image-10",
+        created_image = self.__generate_image()
+
+        self.assertEqual(
+            created_image["error"]["code"], 400,
+            "Expected a 400 code for invalid model"
+        )
+        self.assertEqual(
+            created_image["error"]["message"],
+            'Provider \'["openai\' does not exists.', 
+            "Expected an error message when model does not exists"
+        )
+
+
+    def test_generate_image_no_model(self):
+        self.new_image["model"] = ""
+        created_image = self.__generate_image()
+
+        self.assertEqual(
+            created_image["error"]["code"], 400,
+            "Expected a 400 code for no model"
+        )
+        self.assertEqual(
+            created_image["error"]["message"],
+            "Invalid 'model' name. Must follow pattern {provider}/{modelName}", 
+            "Expected an error message when no model is provided"
+        )
+
+
+    def test_generate_image_no_prompt(self):
+        self.new_image["prompt"] = ""
+        created_image = self.__generate_image()
+
+        self.assertEqual(
+            created_image["error"]["type"],
+            "invalid_request_error",
+            "Expected a 400 code for no model"
+        )
+        self.assertEqual(
+            created_image["error"]["param"], "prompt", 
+            "Expected an error message when no model is provided"
+        )
+
+
+    def test_generate_image_specific_n(self):
+        self.new_image["n"] = 2
+
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 2, "Expected two images to be generated")
+
+
+    def test_generate_image_no_n(self):
+        self.new_image["n"] = None # default is 1
+
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 1, "Expected an image to be generated")
+
+
+    def test_generate_image_no_supported_n(self):
+        self.new_image["model"] = "openai/dall-e-3"
+        self.new_image["n"] = 5
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid 'n': integer above maximum value",
+            created_image["error"]["message"],
+            "Expected an error message when n is not supported by the model"
+        )
+
+
+    def test_generate_image_no_quality(self):
+        self.new_image["quality"] = ""
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid value: ''. Supported values are: 'low', 'medium', 'high', and 'auto'",
+            created_image["error"]["message"],
+            "Expected an error message when quality is not provided"
+        )
+    
+
+    def test_generate_image_no_supported_quality(self):
+        self.new_image["model"] = "openai/dall-e-3"
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid value: 'high'. Supported values are: 'standard' and 'hd'",
+            created_image["error"]["message"],
+            "Expected an error message when quality is not supported by the model"
+        )
+
+
+    def test_generate_image_no_size(self):
+        self.new_image["size"] = ""
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid value: ''. Supported values are: '1024x1024', '1024x1536', '1536x1024', and 'auto'",
+            created_image["error"]["message"],
+            "Expected an error message when no size is provided"
+        )
+
+
+    def test_generate_image_no_supported_size(self):
+        self.new_image["size"] = 1024
+        self.new_image["quality"] = None
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid type for 'size': expected one of '1024x1024', '1024x1536', '1536x1024', or 'auto', but got an integer instead",
+            created_image["error"]["message"],
+            "Expected an error message when no size is provided"
+        )
+    
+
+    def test_generate_image_with_aspect_ratio(self):
+        self.new_image["model"] = "vertex_ai/imagen-3.0-generate-001"
+        self.new_image["aspect_ratio"] = "4:3"
+        self.new_image["quality"] = None
+
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 1, "Expected an image to be generated")

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

@@ -287,21 +287,18 @@ class TestAILabCreateAgentIntegration(TestCase):
                 )
 
     
-    @unittest.skip("Agent is getting created regardless of the prompt instructions being empty")
     def test_create_agent_no_prompt_instructions(self):
         self.new_agent.agent_data.prompt.instructions = ""
-        with self.assertRaises(ValidationError) as exception:
-            self.__create_agent()
-        self.assertIn(
-            "instructions",
-            str(exception.exception),
-            "Expected a validation error about allowed values for instructions"
-        )
+        self.created_agent = self.__create_agent()
 
-        self.assertIn(
-            "Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]",
-            str(exception.exception),
-            "Expected a validation error about allowed values for instructions"
+        self.assertTrue(
+            isinstance(self.created_agent, Agent),
+            "Expected a created agent"
+        )
+        
+        self.assertIsNone(
+            self.created_agent.agent_data.prompt.instructions,
+            "Expected the created agent to not have prompt instructions"
         )
 
     

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

@@ -207,28 +207,20 @@ class TestAILabUpdateAgentIntegration(TestCase):
                     f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
                 )
 
-    
+    # TODO: Change validation when API behavior is fixed
     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):
-                if auto_publish == False:
-                    with self.assertRaises(ValidationError) as exception:
-                        self.__update_agent(automatic_publish=auto_publish)
+                
+                # If the agent is not published, the API returns a warning message for invalid model name. However, the sdk mapping is not returning it.
+                if auto_publish == False:                    
+                    updated_agent = 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" 
-                    )
+                    self.assertTrue(self.isInstance(updated_agent), Agent)
                 else:                 
                     with self.assertRaises(APIError) as exception:
                         self.__update_agent(automatic_publish=auto_publish)

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

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

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

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

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

@@ -0,0 +1,91 @@
+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
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabGetToolIntegration(TestCase):   
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.tool_id = "e3e4d64f-ce52-467e-90a9-aa4d08425e82"
+        self.filter_settings = FilterSettings(
+            revision="0",
+            version="0"
+        )
+
+    def __get_tool(self, tool_id=None, filter_settings: FilterSettings = None):
+        return self.ai_lab_manager.get_tool(
+            tool_id=self.tool_id if tool_id is None else tool_id,
+            filter_settings=self.filter_settings if filter_settings is None else filter_settings
+        )
+
+    def test_get_tool(self):
+        tool = self.__get_tool()
+        self.assertIsInstance(tool, Tool, "Expected a tool") 
+ 
+
+    @unittest.skip("Skipped: Validate that when no tool_id is provided, the complete tool list is returned")
+    def test_get_tool_no_tool_id(self):
+        with self.assertRaises(Exception) as context:
+            self.__get_tool(tool_id="")
+         
+    
+    def test_get_tool_invalid_tool_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(APIError) as context:
+            self.__get_tool(tool_id=invalid_id)
+        self.assertIn(
+            f"Tool not found [IdOrName= {invalid_id}].",
+            str(context.exception),
+            "Expected an error for invalid tool id"
+        )
+
+
+    def test_get_tool_no_revision(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = None
+        tool = self.__get_tool(filter_settings=filter_settings)
+
+        self.assertIsInstance(tool, Tool, "Expected a tool")
+        self.assertGreaterEqual(tool.revision, 1, "Expected tool revision to be the latest")
+
+    
+    def test_get_tool_by_revision(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = "6"
+        tool = self.__get_tool(filter_settings=filter_settings)
+
+        self.assertEqual(6, tool.revision, "Expected agent revision to be 6")
+
+
+    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:
+            self.__get_tool(filter_settings=filter_settings)
+        self.assertIn(
+            f"Requested revision not found [revision={filter_settings.revision}].",
+            str(context.exception),
+            "Expected an error for revision not found"
+        )
+
+    #TODO: The API is returning the version of the tool, but the sdk does not
+    def test_get_tool_no_version(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = None
+        tool = self.__get_tool(filter_settings=filter_settings)
+
+        self.assertIsInstance(tool, Tool, "Expected a tool") 
+
+
+    #TODO: The API is returning the version of the tool, but the sdk does not      
+    def test_get_tool_by_version(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = "1"
+        tool = self.__get_tool(filter_settings=filter_settings)
+        
+        self.assertIsInstance(tool, Tool, "Expected a tool") 

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

@@ -0,0 +1,38 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import ToolList, FilterSettings
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListToolsIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.filter_settings = FilterSettings(
+            allow_external=False,
+            allow_drafts=True,
+            access_scope="private"
+        )
+    """ list-tools or lt            List tools
+        --project-id or --pid           ID of the project
+        --id                    ID of the tool to filter by. Defaults to an empty string (no filtering).
+        --count                 Number of tools to retrieve. Defaults to '100'.
+        --access-scope          Access scope of the tools, either "public" or "private". Defaults to "public".
+        --allow-drafts          Whether to include draft tools. Defaults to 1 (True).
+        --scope                 Scope of the tools, must be 'builtin', 'external', or 'api'. Defaults to 'api'.
+        --allow-external                Whether to include external tools. Defaults to 1 (True). """
+
+    def __list_tools(self, filter_settings: FilterSettings = None):
+        filter_settings = filter_settings if filter_settings != None else self.filter_settings
+        return self.ai_lab_manager.list_tools(filter_settings=filter_settings)
+    
+    def test_private_list_tools(self):
+        result = self.__list_tools()
+        self.assertIsInstance(result, ToolList , "Expected a list of tools") 
+        print(result)
+        for tool in result.tools:
+            self.assertTrue(tool.access_scope == "private", "Expected all tools to be private")
+        
+
+

pygeai/tests/snippets/lab/agents/create_agent_edge_case.py

@@ -0,0 +1,48 @@
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model, Sampling, PromptExample, PromptOutput
+
+agent = Agent(
+    id="f64ba214-152b-4dd4-be0d-2920da415f5d",
+    status="active",
+    name="Private Translator V25",
+    access_scope="private",
+    public_name="com.genexus.geai.private_translator#",
+    job_description="Translates",
+    avatar_image="https://www.shareicon.net/data/128x128/2016/11/09/851442_logo_512x512.png",
+    description="Agent that translates from any language to english.",
+    is_draft=False,
+    is_readonly=False,
+    revision=1,
+    version=None,
+    agent_data=AgentData(
+        prompt=Prompt(
+            instructions="the user will provide a text, you must return the same text translated to english",
+            inputs=["text", "avoid slang indicator"],
+            outputs=[
+                PromptOutput(key="translated_text", description="translated text, with slang or not depending on the indication. in plain text."),
+                PromptOutput(key="summary", description="a summary in the original language of the text to be translated, also in plain text.")
+            ],
+            examples=[
+                PromptExample(input_data="opitiiiis mundo [no-slang]", output='{"translated_text":"hello world","summary":"saludo"}'),
+                PromptExample(input_data="esto es una prueba pincheguey [keep-slang]", output='{"translated_text":"this is a test pal","summary":"prueba"}')
+            ]
+        ),
+        llm_config=LlmConfig(
+            max_tokens=5000,
+            timeout=0,
+            sampling=Sampling(temperature=0.5, top_k=0, top_p=0)
+        ),
+        models=[Model(name="gpt-4-turbo-preview")]
+    )
+)
+
+
+manager = AILabManager()
+result = manager.create_agent(
+    agent=agent,
+    automatic_publish=False
+)
+
+
+print(f"Agent: {agent.to_dict()}")
+

pygeai/tests/snippets/lab/agents/create_agent_without_instructions.py

@@ -0,0 +1,48 @@
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model, Sampling, PromptExample, PromptOutput
+
+agent = Agent(
+    id="f64ba214-152b-4dd4-be0d-2920da415f5d",
+    status="active",
+    name="Private Translator V25",
+    access_scope="private",
+    public_name="com.genexus.geai.private_translator_25",
+    job_description="Translates",
+    avatar_image="https://www.shareicon.net/data/128x128/2016/11/09/851442_logo_512x512.png",
+    description="Agent that translates from any language to english.",
+    is_draft=False,
+    is_readonly=False,
+    revision=1,
+    version=None,
+    agent_data=AgentData(
+        prompt=Prompt(
+            instructions="the user will provide a text, you must return the same text translated to english",
+            inputs=["text", "avoid slang indicator"],
+            outputs=[
+                PromptOutput(key="translated_text", description="translated text, with slang or not depending on the indication. in plain text."),
+                PromptOutput(key="summary", description="a summary in the original language of the text to be translated, also in plain text.")
+            ],
+            examples=[
+                PromptExample(input_data="opitiiiis mundo [no-slang]", output='{"translated_text":"hello world","summary":"saludo"}'),
+                PromptExample(input_data="esto es una prueba pincheguey [keep-slang]", output='{"translated_text":"this is a test pal","summary":"prueba"}')
+            ]
+        ),
+        llm_config=LlmConfig(
+            max_tokens=5000,
+            timeout=0,
+            sampling=Sampling(temperature=0.5, top_k=0, top_p=0)
+        ),
+        models=[Model(name="gpt-4-turbo-preview")]
+    )
+)
+
+
+manager = AILabManager()
+result = manager.create_agent(
+    agent=agent,
+    automatic_publish=False
+)
+
+
+print(f"Agent: {agent.to_dict()}")
+

pygeai/tests/snippets/lab/tools/create_tool_edge_case.py

@@ -0,0 +1,50 @@
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Tool, ToolParameter
+
+parameters = [
+    ToolParameter(
+        key="input",
+        data_type="String",
+        description="some input that the tool needs.",
+        is_required=True
+    ),
+    ToolParameter(
+        key="some_nonsensitive_id",
+        data_type="String",
+        description="Configuration that is static, in the sense that whenever the tool is used, the value for this parameter is configured here. The llm will not know about it.",
+        is_required=True,
+        type="config",
+        from_secret=False,
+        value="b001e30b4016001f5f76b9ae9215ac40"
+    ),
+    ToolParameter(
+        key="api_token",
+        data_type="String",
+        description="Configuration that is static, but it is sensitive information . The value is stored in secret-manager",
+        is_required=True,
+        type="config",
+        value="0cd84dc7-f3f5-4a03-9288-cdfd8d72fde1"
+    )
+]
+
+tool = Tool(
+    name="sample_tool_v5",
+    access_scope="private",
+    public_name="sample.tool.test#",
+    description="a builtin tool that does something but really does nothing cos it does not exist.",
+    scope="builtin",
+    parameters=parameters
+)
+
+
+manager = AILabManager()
+
+
+result = manager.create_tool(
+    tool=tool,
+    automatic_publish=False
+)
+
+print(f"Created tool: {result.name}, ID: {result.id}")
+print(f"Description: {result.description}")
+print(f"Messages: {result.messages}")

{pygeai-0.4.0b2.dist-info → pygeai-0.4.0b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai
-Version: 0.4.0b2
+Version: 0.4.0b4
 Summary: Software Development Kit to interact with Globant Enterprise AI.
 Author-email: Globant <geai-sdk@globant.com>
 License-Expression: MIT
@@ -41,11 +41,11 @@ Dynamic: license-file
 
 PyGEAI is a Software Development Kit (SDK) for interacting with [Globant Enterprise AI](https://wiki.genexus.com/enterprise-ai/wiki?8,Table+of+contents%3AEnterprise+AI). It comprises libraries, tools, code samples, and documentation to simplify your experience with the platform.
 
-## Repository
+## Terms and conditions
 
-Find the PyGEAI source code and documentation in the following GitHub repository:
+By using the Python SDK to interact with Globant Enterprise AI, you agree with the following Terms and Conditions:
 
-[GitHub repository](https://github.com/RT-GEN029-GI/pygeai)
+[Terms and Conditions](https://www.globant.com/enterprise-ai/terms-of-use)
 
 ## Compatibility
 This package is compatible with the Globant Enterprise AI release from June 2025.

{pygeai-0.4.0b2.dist-info → pygeai-0.4.0b4.dist-info}/RECORD

@@ -16,7 +16,7 @@ pygeai/assistant/rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 pygeai/assistant/rag/clients.py,sha256=9a8loVLRnVkA3nHvvOpbdUEhy_TEnHm1rhdBYrBVABE,15893
 pygeai/assistant/rag/endpoints.py,sha256=7YlHIvAYj3-xsCWtVMDYobxXbAO0lCo9yJdOrQxwCrQ,1145
 pygeai/assistant/rag/mappers.py,sha256=n3aeNXqz_7zq_JWq5wJfeNX1kvV3arOxAoUsqRYOZsc,8645
-pygeai/assistant/rag/models.py,sha256=xqYJiFMpDztRdjsb-pSAd1k3POmLJFM4hH6SaJ_4pto,15732
+pygeai/assistant/rag/models.py,sha256=g5UiHuRjobgU1WgUMxeBzXykxgJ5q7eb_YY8qDciNvw,15732
 pygeai/assistant/rag/responses.py,sha256=fY97ibsCVLQ3Ssnjuvj-JeA883WqjOw7ZdxbpQp_B1E,196
 pygeai/chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/chat/clients.py,sha256=QEyeTIPxp6xXKAEkE_XkjIxZDnaH808GKhIYr7ulrSA,10785
@@ -144,7 +144,7 @@ pygeai/health/endpoints.py,sha256=UAzMcqSXZtMj4r8M8B7a_a5LT6X_jMFNsCTvcsjNTYA,71
 pygeai/lab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/constants.py,sha256=ddgDnXP4GD0woi-FUJaJXzaWS3H6zmDN0B-v8utM95Q,170
 pygeai/lab/managers.py,sha256=9wV6SipzsIwFP9SXsKqZ0X5x6KbUuo6iCxPZF4zNGj4,72714
-pygeai/lab/models.py,sha256=uxhmogA0234eXXmqsVRE7EQQsmqx_BBHYXjhWkKso40,71386
+pygeai/lab/models.py,sha256=1m41gSqpXZVO9AcPVxzlsC-TgxZcCsgGUbpN5zoDMjU,71451
 pygeai/lab/runners.py,sha256=-uaCPHpFyiKtVOxlEjPjAc9h-onSdGAcYJ5IAZPqlb0,4147
 pygeai/lab/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/agents/clients.py,sha256=2SYNjyD9LZaOUxmTcrwzqcHwW7K1wAmYwen_u0G-RfU,22659
@@ -153,7 +153,7 @@ pygeai/lab/agents/mappers.py,sha256=K6rxsO2Nq6GglmCUmyDKUNmzTG8HRbCelap6qaVKXQw,
 pygeai/lab/processes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/processes/clients.py,sha256=C1YYJE7c5qJSZUIDKzo5kK-LOZP6jbdrG01aE8zoEYg,51403
 pygeai/lab/processes/endpoints.py,sha256=nFIEcNP22xe4j6URI6KcwTh7h-xgYjYYuHT6PDPiO3I,2100
-pygeai/lab/processes/mappers.py,sha256=QBpDT3wlyRNNUMa_vDP2vhQ4pD0vwnjXc1ahckfRVX0,15807
+pygeai/lab/processes/mappers.py,sha256=YOWcVKdcJmLMAq-f3qevzqQ8L_hjb0_jVXBdCHutpzk,15815
 pygeai/lab/spec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/spec/loader.py,sha256=Dq9MhLqFwF4RPdBBaqKPGqt43-PrNlsHpe-NXe4S0qQ,709
 pygeai/lab/spec/parsers.py,sha256=oG7tY-GylweRxpvtCl3p53t0IoTX3UZFiB77x__3Qp8,646
@@ -164,7 +164,7 @@ pygeai/lab/strategies/mappers.py,sha256=6C_jubAVXMKLGQy5NUD0OX7SlrU2mLe2QsgzeJ1-
 pygeai/lab/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/tools/clients.py,sha256=TfgociWyvzao3B6g2VfjAb6FmXp1YqmJRG2TT7RwOic,27441
 pygeai/lab/tools/endpoints.py,sha256=HiGoMs4OVeCgH7EAERTtifFPl53NryA1Awh7D6AO8bA,699
-pygeai/lab/tools/mappers.py,sha256=6xcR7lIOYrvUG8SERQIx_bsK-_To316BUql8UPLHWco,4978
+pygeai/lab/tools/mappers.py,sha256=bYi5k36h0k4mCvOnV-r8YOHKz0U9P0mH21GNs20w2eM,4998
 pygeai/man/__init__.py,sha256=gqGI92vUPt6RPweoWX3mTUYPWNDlm6aGUjQOnYXqthk,53
 pygeai/man/man1/__init__.py,sha256=CFvES6cP_sbhgpm-I-QSbPC1f7Bw7cFsMW2-sxm4FtM,54
 pygeai/man/man1/geai-proxy.1,sha256=N5jtjzS5dB3JjAkG0Rw8EBzhC6Jgoy6zbS7XDgcE4EA,6735
@@ -268,15 +268,22 @@ pygeai/tests/gam/test_clients.py,sha256=vNz-4ux0cubztTY-_fEPWEoMCt5VAmZLecd0V-sE
 pygeai/tests/health/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/health/test_clients.py,sha256=kfakkZHFMfo2IAN-PzmtMGmgR4iNiN1RpRopI--0qHI,1525
 pygeai/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygeai/tests/integration/chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygeai/tests/integration/chat/test_generate_image.py,sha256=byCQQK6dIy68yPAhAa66bh7N0Xz5WnKSClx1vaIIzZA,5431
 pygeai/tests/integration/lab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/integration/lab/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/integration/lab/agents/test_agents_list.py,sha256=F2KUCdeiaBC3dn8ARNWqSz_kJcRyA0HC1nquhamN35Q,4187
-pygeai/tests/integration/lab/agents/test_create_agent.py,sha256=J3_QYCQM02LVdYZN3Y4nFmqn43_BgbV6ZELtLhZnjl0,14475
+pygeai/tests/integration/lab/agents/test_create_agent.py,sha256=yL3owPJP0RoHSy3lEAdH06LJXqxgt3f2l2plk75d4cc,14206
 pygeai/tests/integration/lab/agents/test_create_sharing_link.py,sha256=y-e8Q_TfuLz7XXMRERSKA_-OQJUMBIsJcK0lQ0Oh858,2467
 pygeai/tests/integration/lab/agents/test_delete_agent.py,sha256=sb3RfoZJdzQvcVdNcXY2C2FO3yY1ZNiAZ_6Ay6f331E,2524
 pygeai/tests/integration/lab/agents/test_get_agent.py,sha256=oW1F6SENvhL9jZC021Rj-f_Xek2DSTx3SsZBr3YT6Hk,3666
 pygeai/tests/integration/lab/agents/test_publish_agent_revision.py,sha256=4vpuAVBenLCyWvaKTA2PQVLn_e-abGDscngUzZm3dMs,5284
-pygeai/tests/integration/lab/agents/test_update_agent.py,sha256=vme9TJij46U55oOvUYGdKRyzZn-UKzXXYGJH0-zCeRs,11959
+pygeai/tests/integration/lab/agents/test_update_agent.py,sha256=1seho_GOtOHik_YJ9GPA4McSZorohhFRvuzY7UYXbxo,11726
+pygeai/tests/integration/lab/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygeai/tests/integration/lab/tools/test_create_tool.py,sha256=G74P0_DUMpfCH3HBvImpUKD_aMHT8V6uPyVzo2V81lg,12479
+pygeai/tests/integration/lab/tools/test_delete_tool.py,sha256=wy979nZh8ERd-k3jhJTjHqG4wxWE4sx-r4yn2nBc7Aw,2913
+pygeai/tests/integration/lab/tools/test_get_tool.py,sha256=3fVDQlklmvOUgYDp0ATv5RqRmApgD4Qw_YGqjBOaOOo,3437
+pygeai/tests/integration/lab/tools/test_list_tools.py,sha256=afJ-Y11uCJEvfzs0FzdjExqksO3PswglWHEg2_nBJ-4,1725
 pygeai/tests/lab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/lab/test_managers.py,sha256=AsOAvyCkRpbskEy214aV2TwrqilWH6bxOiTWDOb1twQ,29778
 pygeai/tests/lab/test_mappers.py,sha256=2cLSggf168XWFpeZeBR7uJ-8C32TKb7qA91i_9fr_b0,11409
@@ -368,6 +375,8 @@ pygeai/tests/snippets/lab/runner_1.py,sha256=QD92MvC22wpWj6YyrSgpp46EcL0ciac2x1z
 pygeai/tests/snippets/lab/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/snippets/lab/agents/create_agent.py,sha256=EVyfQzDST9A9KaM0ToZJKlJ7yCbfhpSVkVK_MaUVQPw,1875
 pygeai/tests/snippets/lab/agents/create_agent_2.py,sha256=jd7HKhle_c0S0vI80AejOyLaNqBWkILlRF_znzyCGcQ,1879
+pygeai/tests/snippets/lab/agents/create_agent_edge_case.py,sha256=8dA9giNdsHjFZsIWTlBFk8e1QS3YtbZxklsVu0ZrDrk,1877
+pygeai/tests/snippets/lab/agents/create_agent_without_instructions.py,sha256=jd7HKhle_c0S0vI80AejOyLaNqBWkILlRF_znzyCGcQ,1879
 pygeai/tests/snippets/lab/agents/delete_agent.py,sha256=GfDX667_V3tZMz3vjsbrxoFZggzpwjZYH_PVO2Qjw5s,269
 pygeai/tests/snippets/lab/agents/get_agent.py,sha256=bcqloJHwmNsFjEfri6QIRaTuHzwLtfEqIQPIC5pdkWQ,516
 pygeai/tests/snippets/lab/agents/get_sharing_link.py,sha256=2mYPwMgFFbqzmWZEBrFYSjdZscVyjJYCs4A3L0x8Sr8,355
@@ -394,6 +403,7 @@ pygeai/tests/snippets/lab/strategies/list_reasoning_strategies.py,sha256=4pqsW16
 pygeai/tests/snippets/lab/strategies/update_reasoning_strategy.py,sha256=OIoHNkdnXbC9GacPgXUG1jKlVizVtWfRI-E8_3xF5b0,889
 pygeai/tests/snippets/lab/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/snippets/lab/tools/create_tool.py,sha256=dreldR8QIu9Q9tjOG2hkD6b8KZa_VrwSfSnCrzPgQLA,1400
+pygeai/tests/snippets/lab/tools/create_tool_edge_case.py,sha256=8w4mvoRTMTyc70yYm2bgV2dr_Rh5QpPJR8VoqX-eY-s,1465
 pygeai/tests/snippets/lab/tools/delete_tool.py,sha256=pnIkYvdP7X7Gx79AMK5MSVliIXdHSpyVwRhH3kgi7ys,452
 pygeai/tests/snippets/lab/tools/get_parameter.py,sha256=dXdlHhoWxzZIYdsvHKnLLT5Vff2Tip46XCoOo-B8Gf0,490
 pygeai/tests/snippets/lab/tools/get_tool.py,sha256=-fkKAE6nflwtLY_Lf6itZJyx_9aanFp-TSDHUzub1AM,477
@@ -482,9 +492,9 @@ pygeai/vendor/a2a/utils/helpers.py,sha256=6Tbd8SVfXvdNEk6WYmLOjrAxkzFf1aIg8dkFfB
 pygeai/vendor/a2a/utils/message.py,sha256=gc_EKO69CJ4HkR76IFgsy-kENJz1dn7CfSgWJWvt-gs,2197
 pygeai/vendor/a2a/utils/task.py,sha256=BYRA_L1HpoUGJAVlyHML0lCM9Awhf2Ovjj7oPFXKbh0,1647
 pygeai/vendor/a2a/utils/telemetry.py,sha256=VvSp1Ztqaobkmq9-3sNhhPEilJS32-JTSfKzegkj6FU,10861
-pygeai-0.4.0b2.dist-info/licenses/LICENSE,sha256=eHfqo7-AWS8cMq0cg03lq7owsLeCmZA-xS5L0kuHnl8,1474
-pygeai-0.4.0b2.dist-info/METADATA,sha256=bpntcqljAoYNvhEDrvlR5sjc3QDZtp2MxaFPmtCnepA,6882
-pygeai-0.4.0b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pygeai-0.4.0b2.dist-info/entry_points.txt,sha256=OAmwuXVCQBTCE3HeVegVd37hbhCcp9TPahvdrCuMYWw,178
-pygeai-0.4.0b2.dist-info/top_level.txt,sha256=bJFwp2tURmCfB94yXDF7ylvdSJXFDDJsyUOb-7PJgwc,7
-pygeai-0.4.0b2.dist-info/RECORD,,
+pygeai-0.4.0b4.dist-info/licenses/LICENSE,sha256=eHfqo7-AWS8cMq0cg03lq7owsLeCmZA-xS5L0kuHnl8,1474
+pygeai-0.4.0b4.dist-info/METADATA,sha256=plyocQ_kqcryzOcFS26Ontgdg5bv5yMrbcitm3bsOcQ,6940
+pygeai-0.4.0b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pygeai-0.4.0b4.dist-info/entry_points.txt,sha256=OAmwuXVCQBTCE3HeVegVd37hbhCcp9TPahvdrCuMYWw,178
+pygeai-0.4.0b4.dist-info/top_level.txt,sha256=bJFwp2tURmCfB94yXDF7ylvdSJXFDDJsyUOb-7PJgwc,7
+pygeai-0.4.0b4.dist-info/RECORD,,