pygeai 0.4.0b2__tar.gz → 0.4.0b4__tar.gz

{pygeai-0.4.0b2/pygeai.egg-info → pygeai-0.4.0b4}/PKG-INFO

@@ -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 → pygeai-0.4.0b4}/README.md

@@ -2,11 +2,11 @@
 
 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 → pygeai-0.4.0b4}/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-0.4.0b2 → pygeai-0.4.0b4}/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-0.4.0b2 → pygeai-0.4.0b4}/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-0.4.0b2 → pygeai-0.4.0b4}/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-0.4.0b4/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-0.4.0b2 → pygeai-0.4.0b4}/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-0.4.0b2 → pygeai-0.4.0b4}/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-0.4.0b4/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")