pygeai 0.4.0b1__py3-none-any.whl → 0.4.0b3__py3-none-any.whl

pygeai/lab/models.py

@@ -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/migration/strategies.py

@@ -124,11 +124,11 @@ class AgentMigrationStrategy(MigrationStrategy):
     def __migrate_agent(self):
         new_agent = None
         try:
-            source_agent = self.source_manager.get_agent(project_id=self.from_project_id, agent_id=self.agent_id)
+            source_agent = self.source_manager.get_agent(agent_id=self.agent_id)
             if not isinstance(source_agent, Agent):
                 raise ValueError("Unable to retrieve requested agent.")
 
-            new_agent = self.destination_manager.create_agent(project_id=self.to_project_id, agent=source_agent)
+            new_agent = self.destination_manager.create_agent(agent=source_agent)
         except Exception as e:
             Console.write_stderr(f"Agent migration failed: {e} \n")
 
@@ -174,11 +174,11 @@ class ToolMigrationStrategy(MigrationStrategy):
     def __migrate_tool(self):
         new_tool = None
         try:
-            source_tool = self.source_manager.get_tool(project_id=self.from_project_id, tool_id=self.tool_id)
+            source_tool = self.source_manager.get_tool(tool_id=self.tool_id)
             if not isinstance(source_tool, Tool):
                 raise ValueError("Unable to retrieve requested tool.")
 
-            new_tool = self.destination_manager.create_tool(project_id=self.to_project_id, tool=source_tool)
+            new_tool = self.destination_manager.create_tool(tool=source_tool)
         except Exception as e:
             Console.write_stderr(f"Tool migration failed: {e}")
 
@@ -224,11 +224,11 @@ class AgenticProcessMigrationStrategy(MigrationStrategy):
     def __migrate_process(self):
         new_process = None
         try:
-            source_process = self.source_manager.get_process(project_id=self.from_project_id, process_id=self.process_id)
+            source_process = self.source_manager.get_process(process_id=self.process_id)
             if not isinstance(source_process, AgenticProcess):
                 raise ValueError("Unable to retrieve requested process.")
 
-            new_process = self.destination_manager.create_process(project_id=self.to_project_id, process=source_process)
+            new_process = self.destination_manager.create_process(process=source_process)
         except Exception as e:
             Console.write_stderr(f"Process migration failed: {e}")
 
@@ -274,11 +274,11 @@ class TaskMigrationStrategy(MigrationStrategy):
     def __migrate_task(self):
         new_task = None
         try:
-            source_task = self.source_manager.get_task(project_id=self.from_project_id, task_id=self.task_id)
+            source_task = self.source_manager.get_task(task_id=self.task_id)
             if not isinstance(source_task, Task):
                 raise ValueError("Unable to retrieve requested task.")
 
-            new_task = self.destination_manager.create_task(project_id=self.to_project_id, task=source_task)
+            new_task = self.destination_manager.create_task(task=source_task)
         except Exception as e:
             Console.write_stderr(f"Task migration failed: {e}")
 

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

@@ -0,0 +1,294 @@
+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):
+        #random_str = str(uuid.uuid4())
+        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/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.0b1.dist-info → pygeai-0.4.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai
-Version: 0.4.0b1
+Version: 0.4.0b3
 Summary: Software Development Kit to interact with Globant Enterprise AI.
 Author-email: Globant <geai-sdk@globant.com>
 License-Expression: MIT

{pygeai-0.4.0b1.dist-info → pygeai-0.4.0b3.dist-info}/RECORD

@@ -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=djbSMdm95kgnqsgohfXTSybylFp_jevMj6SoWuU_P9A,71440
 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
@@ -170,7 +170,7 @@ pygeai/man/man1/__init__.py,sha256=CFvES6cP_sbhgpm-I-QSbPC1f7Bw7cFsMW2-sxm4FtM,5
 pygeai/man/man1/geai-proxy.1,sha256=N5jtjzS5dB3JjAkG0Rw8EBzhC6Jgoy6zbS7XDgcE4EA,6735
 pygeai/man/man1/geai.1,sha256=dRJjqXLu4PRr5tELX-TveOrvp-J085rTV0NbqL5I30Q,51162
 pygeai/migration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pygeai/migration/strategies.py,sha256=fedXqdtnAY57eeMI3RP5KhkjzVtYD654G51pMJb41fw,10041
+pygeai/migration/strategies.py,sha256=fNTPuAPrGPxjbQN6zQn7qaVHksft_rC8doADdUw1LWQ,9785
 pygeai/migration/tools.py,sha256=DuBWwS72VxXF2b95aw89u0aLBjHP1UhD5GBlUtuG8nA,321
 pygeai/organization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/organization/clients.py,sha256=O9RMeFm8gm5e6OoJl2y3JTS_MUZEp2Twc8AOpsUTj4M,10073
@@ -277,6 +277,10 @@ pygeai/tests/integration/lab/agents/test_delete_agent.py,sha256=sb3RfoZJdzQvcVdN
 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/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pygeai/tests/integration/lab/tools/test_create_tool.py,sha256=QjJT_L47wwl8_GcqIRCMgDiF817rADHBgY-xPO3omd0,12519
+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/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 +372,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 +400,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 +489,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.0b1.dist-info/licenses/LICENSE,sha256=eHfqo7-AWS8cMq0cg03lq7owsLeCmZA-xS5L0kuHnl8,1474
-pygeai-0.4.0b1.dist-info/METADATA,sha256=7t753dmdmoBFILz_q2iiOFD3VWBzTOfPOXqtyr4HUSA,6882
-pygeai-0.4.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pygeai-0.4.0b1.dist-info/entry_points.txt,sha256=OAmwuXVCQBTCE3HeVegVd37hbhCcp9TPahvdrCuMYWw,178
-pygeai-0.4.0b1.dist-info/top_level.txt,sha256=bJFwp2tURmCfB94yXDF7ylvdSJXFDDJsyUOb-7PJgwc,7
-pygeai-0.4.0b1.dist-info/RECORD,,
+pygeai-0.4.0b3.dist-info/licenses/LICENSE,sha256=eHfqo7-AWS8cMq0cg03lq7owsLeCmZA-xS5L0kuHnl8,1474
+pygeai-0.4.0b3.dist-info/METADATA,sha256=lq_Zxuj3ryFc5mcZrxNp29ohgxV_qOBtyQJqPWumxWk,6882
+pygeai-0.4.0b3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pygeai-0.4.0b3.dist-info/entry_points.txt,sha256=OAmwuXVCQBTCE3HeVegVd37hbhCcp9TPahvdrCuMYWw,178
+pygeai-0.4.0b3.dist-info/top_level.txt,sha256=bJFwp2tURmCfB94yXDF7ylvdSJXFDDJsyUOb-7PJgwc,7
+pygeai-0.4.0b3.dist-info/RECORD,,