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

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

@@ -1,13 +1,13 @@
 from json import JSONDecodeError
 
 from pygeai import logger
-from pygeai.core.base.clients import BaseClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException
+from pygeai.lab.clients import AILabClient
 from pygeai.lab.strategies.endpoints import LIST_REASONING_STRATEGIES_V2, CREATE_REASONING_STRATEGY_V2, \
     UPDATE_REASONING_STRATEGY_V2, UPSERT_REASONING_STRATEGY_V2, GET_REASONING_STRATEGY_V2
 
 
-class ReasoningStrategyClient(BaseClient):
+class ReasoningStrategyClient(AILabClient):
 
     def list_reasoning_strategies(
             self,
@@ -56,7 +56,6 @@ class ReasoningStrategyClient(BaseClient):
 
     def create_reasoning_strategy(
             self,
-            project_id: str,
             name: str,
             system_prompt: str,
             access_scope: str = "public",
@@ -67,7 +66,6 @@ class ReasoningStrategyClient(BaseClient):
         """
         Creates a new reasoning strategy in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param name: str - Name of the reasoning strategy.
         :param system_prompt: str - System prompt for the strategy.
         :param access_scope: str, optional - Access scope, "public" or "private" (default: "public").
@@ -83,7 +81,7 @@ class ReasoningStrategyClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id,
+            "ProjectId": self.project_id,
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
@@ -103,14 +101,13 @@ class ReasoningStrategyClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to create reasoning strategy for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to create reasoning strategy for project {project_id}: {response.text}")
+            logger.error(f"Unable to create reasoning strategy for project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to create reasoning strategy for project {self.project_id}: {response.text}")
 
         return result
 
     def update_reasoning_strategy(
             self,
-            project_id: str,
             reasoning_strategy_id: str,
             name: str = None,
             system_prompt: str = None,
@@ -123,7 +120,6 @@ class ReasoningStrategyClient(BaseClient):
         """
         Updates or upserts a reasoning strategy in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param reasoning_strategy_id: str - Unique identifier of the strategy.
         :param name: str, optional - Updated strategy name.
         :param system_prompt: str, optional - Updated system prompt.
@@ -169,7 +165,7 @@ class ReasoningStrategyClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id,
+            "ProjectId": self.project_id,
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
@@ -181,21 +177,19 @@ class ReasoningStrategyClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to update reasoning strategy {reasoning_strategy_id} in project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to update reasoning strategy {reasoning_strategy_id} in project {project_id}: {response.text}")
+            logger.error(f"Unable to update reasoning strategy {reasoning_strategy_id} in project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to update reasoning strategy {reasoning_strategy_id} in project {self.project_id}: {response.text}")
 
         return result
 
     def get_reasoning_strategy(
             self,
-            project_id: str,
             reasoning_strategy_id: str = None,
             reasoning_strategy_name: str = None
     ):
         """
         Retrieves a reasoning strategy by ID or name in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param reasoning_strategy_id: str, optional - Unique identifier of the strategy.
         :param reasoning_strategy_name: str, optional - Name of the strategy.
         :return: dict - Strategy details.
@@ -210,7 +204,7 @@ class ReasoningStrategyClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         if reasoning_strategy_id:
@@ -225,8 +219,8 @@ class ReasoningStrategyClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to retrieve reasoning strategy {reasoning_strategy_id or reasoning_strategy_name} for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to retrieve reasoning strategy {reasoning_strategy_id or reasoning_strategy_name} for project {project_id}: {response.text}")
+            logger.error(f"Unable to retrieve reasoning strategy {reasoning_strategy_id or reasoning_strategy_name} for project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to retrieve reasoning strategy {reasoning_strategy_id or reasoning_strategy_name} for project {self.project_id}: {response.text}")
 
         return result
     

pygeai/lab/tools/clients.py

@@ -2,18 +2,17 @@ import json
 from json import JSONDecodeError
 
 from pygeai import logger
-from pygeai.core.base.clients import BaseClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException, MissingRequirementException
 from pygeai.lab.constants import VALID_SCOPES, VALID_ACCESS_SCOPES, VALID_REPORT_EVENTS
 from pygeai.lab.tools.endpoints import CREATE_TOOL_V2, LIST_TOOLS_V2, GET_TOOL_V2, UPDATE_TOOL_V2, UPSERT_TOOL_V2, \
     PUBLISH_TOOL_REVISION_V2, GET_PARAMETER_V2, SET_PARAMETER_V2, DELETE_TOOL_V2, EXPORT_TOOL_V2
+from pygeai.lab.clients import AILabClient
 
 
-class ToolClient(BaseClient):
+class ToolClient(AILabClient):
 
     def create_tool(
             self,
-            project_id: str,
             name: str,
             description: str = None,
             scope: str = None,
@@ -29,7 +28,6 @@ class ToolClient(BaseClient):
         """
         Creates a new tool in the specified project.
 
-        :param project_id: str - Unique identifier of the project where the tool will be created.
         :param name: str - Name of the tool. Must be non-empty, unique within the project, and exclude ':' or '/'.
         :param description: str - Description of the tool's purpose, helping agents decide when to use it. Optional.
         :param scope: str - Scope of the tool, either 'builtin', 'external', or 'api'. Optional.
@@ -108,7 +106,7 @@ class ToolClient(BaseClient):
             "Accept": "application/json",
             "Content-Type": "application/json",
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         response = self.api_service.post(
@@ -120,14 +118,13 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to create tool for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to create tool for project {project_id}: {response.text}")
+            logger.error(f"Unable to create tool for project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to create tool for project {self.project_id}: {response.text}")
 
         return result
 
     def list_tools(
             self,
-            project_id: str,
             id: str = "",
             count: str = "100",
             access_scope: str = "public",
@@ -138,7 +135,6 @@ class ToolClient(BaseClient):
         """
         Retrieves a list of tools associated with the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param id: str - ID of the tool to filter by. Defaults to "" (no filtering).
         :param count: str - Number of tools to retrieve. Defaults to "100".
         :param access_scope: str - Access scope of the tools, either "public" or "private". Defaults to "public".
@@ -150,13 +146,13 @@ class ToolClient(BaseClient):
         endpoint = LIST_TOOLS_V2
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         if scope and scope not in VALID_SCOPES:
             raise ValueError(f"Scope must be one of {', '.join(VALID_SCOPES)}.")
 
-        logger.debug(f"Listing tools available for the project with ID: {project_id}")
+        logger.debug(f"Listing tools available for the project with ID: {self.project_id}")
 
         response = self.api_service.get(
             endpoint=endpoint,
@@ -173,14 +169,13 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to list tools for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to list tools for project {project_id}: {response.text}")
+            logger.error(f"Unable to list tools for project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to list tools for project {self.project_id}: {response.text}")
 
         return result
 
     def get_tool(
             self,
-            project_id: str,
             tool_id: str,
             revision: str = 0,
             version: int = 0,
@@ -189,7 +184,6 @@ class ToolClient(BaseClient):
         """
         Retrieves details of a specific tool from the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param tool_id: str - Unique identifier of the tool to retrieve.
         :param revision: str - Revision of the tool to retrieve. Defaults to 0 (latest revision).
         :param version: int - Version of the tool to retrieve. Defaults to 0 (latest version).
@@ -199,7 +193,7 @@ class ToolClient(BaseClient):
         endpoint = GET_TOOL_V2.format(toolId=tool_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         logger.debug(f"Retrieving detail of tool with ID: {tool_id}")
@@ -216,21 +210,19 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to retrieve tool {tool_id} for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to retrieve tool {tool_id} for project {project_id}: {response.text}")
+            logger.error(f"Unable to retrieve tool {tool_id} for project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to retrieve tool {tool_id} for project {self.project_id}: {response.text}")
 
         return result
 
     def delete_tool(
             self,
-            project_id: str,
             tool_id: str = None,
             tool_name: str = None
     ) -> dict | str:
         """
         Deletes a specific tool from the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param tool_id: str, optional - Unique identifier of the tool to delete. Defaults to None.
         :param tool_name: str, optional - Name of the tool to delete. Defaults to None.
         :return: dict or str - JSON response containing the result of the delete operation if successful,
@@ -243,7 +235,7 @@ class ToolClient(BaseClient):
         endpoint = DELETE_TOOL_V2.format(toolId=tool_id if tool_id else tool_name)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         if tool_id:
@@ -257,14 +249,13 @@ class ToolClient(BaseClient):
         )
 
         if response.status_code != 204:
-            logger.error(f"Unable to delete tool {tool_id or tool_name} from project {project_id}: JSON parsing error (status {response.status_code}). Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to delete tool {tool_id or tool_name} from project {project_id}: {response.text}")
+            logger.error(f"Unable to delete tool {tool_id or tool_name} from project {self.project_id}: JSON parsing error (status {response.status_code}). Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to delete tool {tool_id or tool_name} from project {self.project_id}: {response.text}")
         else:
             return {}
 
     def update_tool(
             self,
-            project_id: str,
             tool_id: str,
             name: str = None,
             description: str = None,
@@ -282,7 +273,6 @@ class ToolClient(BaseClient):
         """
         Updates an existing tool in the specified project or upserts it if specified.
 
-        :param project_id: str - Unique identifier of the project containing the tool.
         :param tool_id: str - Unique identifier of the tool to update. Required for update operations.
         :param name: str - Updated name of the tool. Must be non-empty, unique within the project, and exclude ':' or '/' if provided. Optional.
         :param description: str - Updated description of the tool's purpose, helping agents decide when to use it. Optional.
@@ -365,7 +355,7 @@ class ToolClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
         response = self.api_service.put(
             endpoint=endpoint,
@@ -376,21 +366,19 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to update tool {tool_id} in project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to update tool {tool_id} in project {project_id}: {response.text}")
+            logger.error(f"Unable to update tool {tool_id} in project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to update tool {tool_id} in project {self.project_id}: {response.text}")
 
         return result
 
     def publish_tool_revision(
             self,
-            project_id: str,
             tool_id: str,
             revision: str
     ):
         """
         Publishes a specific revision of a tool in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param tool_id: str - Unique identifier of the tool to publish.
         :param revision: str - Revision of the tool to publish.
         :return: dict or str - JSON response containing the result of the publish operation if successful, otherwise the raw response text.
@@ -398,7 +386,7 @@ class ToolClient(BaseClient):
         endpoint = PUBLISH_TOOL_REVISION_V2.format(toolId=tool_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         logger.debug(f"Publishing revision {revision} for tool with ID {tool_id}")
@@ -413,14 +401,13 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to publish revision {revision} for tool {tool_id} in project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to publish revision {revision} for tool {tool_id} in project {project_id}: {response.text}")
+            logger.error(f"Unable to publish revision {revision} for tool {tool_id} in project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to publish revision {revision} for tool {tool_id} in project {self.project_id}: {response.text}")
 
         return result
 
     def get_parameter(
             self,
-            project_id: str,
             tool_id: str = None,
             tool_public_name: str = None,
             revision: str = 0,
@@ -430,7 +417,6 @@ class ToolClient(BaseClient):
         """
         Retrieves details of parameters for a specific tool identified by either its ID or public name in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param tool_id: str, optional - Unique identifier of the tool whose parameters are to be retrieved. Defaults to None.
         :param tool_public_name: str, optional - Public name of the tool whose parameters are to be retrieved. Defaults to None.
         :param revision: str - Revision of the parameters to retrieve. Defaults to "0" (latest revision).
@@ -450,7 +436,7 @@ class ToolClient(BaseClient):
         endpoint = GET_PARAMETER_V2.format(toolPublicName=tool_public_name) if tool_public_name else GET_PARAMETER_V2.format(toolPublicName=tool_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         response = self.api_service.get(
@@ -465,14 +451,13 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to retrieve parameters for tool {tool_id or tool_public_name} in project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to retrieve parameters for tool {tool_id or tool_public_name} in project {project_id}: {response.text}")
+            logger.error(f"Unable to retrieve parameters for tool {tool_id or tool_public_name} in project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to retrieve parameters for tool {tool_id or tool_public_name} in project {self.project_id}: {response.text}")
 
         return result
 
     def set_parameter(
             self,
-            project_id: str,
             tool_id: str = None,
             tool_public_name: str = None,
             parameters: list = None
@@ -480,7 +465,6 @@ class ToolClient(BaseClient):
         """
         Sets or updates parameters for a specific tool identified by either its ID or public name in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param tool_id: str, optional - Unique identifier of the tool whose parameters are to be set. Defaults to None.
         :param tool_public_name: str, optional - Public name of the tool whose parameters are to be set. Defaults to None.
         :param parameters: list - List of parameter dictionaries defining the tool's parameters.
@@ -497,7 +481,7 @@ class ToolClient(BaseClient):
         endpoint = SET_PARAMETER_V2.format(toolPublicName=tool_public_name) if tool_public_name else SET_PARAMETER_V2.format(toolPublicName=tool_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id,
+            "ProjectId": self.project_id,
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
@@ -521,27 +505,23 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to set parameters for tool {tool_id or tool_public_name} in project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to set parameters for tool {tool_id or tool_public_name} in project {project_id}: {response.text}")
+            logger.error(f"Unable to set parameters for tool {tool_id or tool_public_name} in project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to set parameters for tool {tool_id or tool_public_name} in project {self.project_id}: {response.text}")
 
         return result
 
     def export_tool(
             self,
-            project_id: str,
             tool_id: str,
     ) -> dict:
         """
         Retrieves details of a specific tool from the specified project.
 
-        :param project_id: str - Unique identifier of the project containing the tool.
         :param tool_id: str - Unique identifier of the tool to retrieve.
         :return: dict - JSON response containing the tool details.
         :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
         :raises MissingRequirementException: If project_id or tool_id is not provided.
         """
-        if not project_id:
-            raise MissingRequirementException("Cannot retrieve tool without specifying project_id")
 
         if not tool_id:
             raise MissingRequirementException("tool_id must be specified in order to retrieve the tool")
@@ -549,7 +529,7 @@ class ToolClient(BaseClient):
         endpoint = EXPORT_TOOL_V2.format(toolId=tool_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         logger.debug(f"Exporting tool with ID {tool_id}")
@@ -561,7 +541,7 @@ class ToolClient(BaseClient):
         try:
             result = response.json()
         except JSONDecodeError as e:
-            logger.error(f"Unable to export tool {tool_id} for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to export tool {tool_id} for project {project_id}: {response.text}")
+            logger.error(f"Unable to export tool {tool_id} for project {self.project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to export tool {tool_id} for project {self.project_id}: {response.text}")
 
         return result

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")