pygeai 0.4.0b3__py3-none-any.whl → 0.5.0__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.core.common.exceptions import InvalidAPIResponseException, MissingRequirementException, APIResponseError
 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(
@@ -116,18 +114,20 @@ class ToolClient(BaseClient):
             headers=headers,
             data=data
         )
-
+        
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
         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 +138,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 +149,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,
@@ -170,17 +169,19 @@ class ToolClient(BaseClient):
                 "allowExternal": allow_external
             }
         )
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
         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 +190,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 +199,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}")
@@ -213,24 +213,25 @@ class ToolClient(BaseClient):
                 "allowDrafts": allow_drafts,
             }
         )
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
         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 +244,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:
@@ -255,17 +256,19 @@ class ToolClient(BaseClient):
             endpoint=endpoint,
             headers=headers
         )
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
 
         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,
+            tool_id: str = None,
             name: str = None,
             description: str = None,
             scope: str = None,
@@ -282,7 +285,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.
@@ -323,6 +325,8 @@ class ToolClient(BaseClient):
         :raises JSONDecodeError: Caught internally if the response cannot be parsed as JSON; returns raw response text.
         :raises Exception: May be raised by `api_service.put` for network issues, authentication errors, or server-side problems (not caught here).
         """
+        if not (tool_id or name):
+            raise ValueError(f"Either tool ID or tool Name must be defined in order to update tool.")
         if scope and scope not in VALID_SCOPES:
             raise ValueError(f"Scope must be one of {', '.join(VALID_SCOPES)}.")
         if access_scope and access_scope not in VALID_ACCESS_SCOPES:
@@ -365,32 +369,32 @@ class ToolClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
         response = self.api_service.put(
             endpoint=endpoint,
             headers=headers,
             data=data
         )
-
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
         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 +402,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 +417,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 +433,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 +452,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(
@@ -462,17 +464,19 @@ class ToolClient(BaseClient):
                 "allowDrafts": allow_drafts,
             }
         )
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
         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 +484,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 +500,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"
         }
@@ -518,30 +521,24 @@ class ToolClient(BaseClient):
             headers=headers,
             data=data
         )
-        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}")
-
-        return result
+        if response.status_code != 204:
+            logger.error(f"Unable to set parameter for tool {tool_id or tool_public_name} from project {self.project_id}: JSON parsing error (status {response.status_code}). Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to set parameter for tool {tool_id or tool_public_name} from project {self.project_id}: {response.text}")
+        else:
+            return {}
 
     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 +546,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}")
@@ -558,10 +555,13 @@ class ToolClient(BaseClient):
             endpoint=endpoint,
             headers=headers,
         )
+        if response.status_code >= 300:
+            logger.error(f"Invalid status code returned from the API endpoint: {response.text}")
+            raise APIResponseError(f"API returned an error: {response.text}")
         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/assistants/rag/test_create_rag.py

@@ -0,0 +1,91 @@
+from unittest import TestCase
+import uuid
+from pygeai.assistant.managers import AssistantManager
+from pygeai.core.models import WelcomeData, LlmSettings
+from pygeai.assistant.rag.models import (
+    Search,
+    RetrieverOptions,
+    SearchOptions,
+    ChunkOptions,
+    IndexOptions,
+    RAGAssistant,
+)
+
+
+class TestAssistantCreateRagIntegration(TestCase):
+
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.assistant_manager = AssistantManager(alias="beta")
+
+        self.new_rag = self.__load_rag()
+        self.created_rag: RAGAssistant = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created tool
+        """
+        if isinstance(self.created_rag, RAGAssistant):
+            self.assistant_manager.delete_assistant(assistant_name=self.created_rag.name)            
+
+
+    def __load_rag(self):
+        llm_options = LlmSettings(
+            cache=False,
+            temperature=0.1,
+            max_tokens=999,
+            model_name="gpt-3.5-turbo-16k",
+            n=1,
+            presence_penalty=0,
+            frequency_penalty=0,
+            provider="OpenAI",
+            stream=False,
+            top_p=1.0,
+            type=None,
+            verbose=True,
+        )
+
+        retriever_options = RetrieverOptions(type="vectorStore")
+
+        search_options = SearchOptions(
+            history_count=2,
+            llm=llm_options,
+            search=Search(
+                k=5,
+                return_source_documents=False,
+                score_threshold=0,
+                prompt="Use {context} and {question}",
+                template="",
+            ),
+            retriever=retriever_options,
+        )
+
+        chunk_options = ChunkOptions(chunk_size=999, chunk_overlap=0)
+
+        index_options = IndexOptions(chunks=chunk_options)
+
+        welcome_data = WelcomeData(
+            title="Test Profile Welcome Data",
+            description="Test Profile with WelcomeData",
+            features=[],
+            examples_prompt=[],
+        )
+
+        return RAGAssistant(
+            name=str(uuid.uuid4()),
+            description="Test Profile with WelcomeData",
+            search_options=search_options,
+            index_options=index_options,
+            welcome_data=welcome_data,
+        )
+
+
+    def test_create_rag_assistant(self):
+        rag_assistant = self.__load_rag()
+        self.created_rag = self.assistant_manager.create_assistant(rag_assistant)
+
+        self.assertIsInstance(self.created_rag, RAGAssistant, "Failed to create RAG assistant")