pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/lab/agents/clients.py

@@ -1,41 +1,46 @@
-from json import JSONDecodeError
 from typing import Optional, List, Dict
 
-from pygeai.core.base.clients import BaseClient
+from pygeai import logger
+from pygeai.core.common.exceptions import MissingRequirementException, InvalidAPIResponseException
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
 from pygeai.lab.agents.endpoints import CREATE_AGENT_V2, LIST_AGENTS_V2, GET_AGENT_V2, CREATE_SHARING_LINK_V2, \
-    PUBLISH_AGENT_REVISION_V2, DELETE_AGENT_V2, UPDATE_AGENT_V2, UPSERT_AGENT_V2
+    PUBLISH_AGENT_REVISION_V2, DELETE_AGENT_V2, UPDATE_AGENT_V2, UPSERT_AGENT_V2, EXPORT_AGENT_V2, IMPORT_AGENT_V2
+from pygeai.lab.constants import VALID_ACCESS_SCOPES
+from pygeai.lab.clients import AILabClient
 
 
-class AgentClient(BaseClient):
+class AgentClient(AILabClient):
 
     def list_agents(
             self,
-            project_id: str,
             status: str = "",
             start: int = "",
             count: int = "",
             access_scope: str = "public",
             allow_drafts: bool = True,
             allow_external: bool = False
-    ):
+    ) -> dict:
         """
         Retrieves a list of agents associated with the specified project.
 
-        :param project_id: str - Unique identifier of the project.
-        :param status: str - Status of the agents to filter by. Defaults to "" (no filtering).
-        :param start: int - Starting index for pagination. Defaults to "" (no offset).
-        :param count: int - Number of agents to retrieve. Defaults to "" (no limit).
-        :param access_scope: str - Access scope of the agents, either "public" or "private". Defaults to "public".
-        :param allow_drafts: bool - Whether to include draft agents. Defaults to True.
-        :param allow_external: bool - Whether to include external agents. Defaults to False.
-        :return: dict or str - JSON response containing the list of agents if successful, otherwise the raw response text.
+        :param status: str, optional - Filter agents by status (e.g., "active", "draft"). Defaults to "" (no filtering).
+        :param start: int, optional - Starting index for pagination. Defaults to "" (no offset).
+        :param count: int, optional - Maximum number of agents to retrieve. Defaults to "" (no limit).
+        :param access_scope: str, optional - Filter agents by access scope ("public" or "private"). Defaults to "public".
+        :param allow_drafts: bool, optional - Include draft agents in the results. Defaults to True.
+        :param allow_external: bool, optional - Include external agents in the results. Defaults to False.
+        :return: dict - JSON response containing the list of agents.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
         """
         endpoint = LIST_AGENTS_V2
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
+        logger.debug(f"Listing agents for project with ID {self.project_id}")
+
         response = self.api_service.get(
             endpoint=endpoint,
             headers=headers,
@@ -48,16 +53,11 @@ class AgentClient(BaseClient):
                 "allowExternal": allow_external
             }
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, f"list agents for project {self.project_id}")
 
     def create_agent(
             self,
-            project_id: str,
             name: str,
             access_scope: str,
             public_name: str,
@@ -66,6 +66,7 @@ class AgentClient(BaseClient):
             description: str,
             agent_data_prompt: dict,
             agent_data_llm_config: dict,
+            agent_data_strategy_name: str,
             agent_data_models: list,
             agent_data_resource_pools: Optional[List[Dict]] = None,
             automatic_publish: bool = False
@@ -73,42 +74,25 @@ class AgentClient(BaseClient):
         """
         Creates a new agent in the specified project.
 
-        :param project_id: str - Unique identifier of the project where the agent will be created.
-        :param name: str - Name of the agent. Must be non-empty, unique within the project, and exclude ':' or '/'.
-        :param access_scope: str - Access scope of the agent. Must be either 'public' or 'private'. Defaults to 'private'.
-        :param public_name: str - Public name of the agent, required if access_scope is 'public'. Must be unique within the installation and follow a domain/library convention (e.g., 'com.example.my-agent'). Only alphanumeric characters, periods, dashes, and underscores are allowed. Optional if access_scope is 'private'.
-        :param job_description: str - Description of the agent's role. Optional.
-        :param avatar_image: str - URL from which the agent's avatar image will be loaded. Optional.
-        :param description: str - Detailed description of the agent’s purpose. Optional.
-        :param agent_data_prompt: dict - Configuration for the agent's prompt. Must include at least 'context' or 'instructions' for publication. Optional fields include 'examples' with 'inputData' and 'output' pairs. Example structure:
-            {
-                'context': str,
-                'instructions': str,
-                'examples': [{'inputData': str, 'output': str}, ...]
-            }
-        :param agent_data_llm_config: dict - Default LLM configuration for the agent. Optional. Example structure:
-            {
-                'maxTokens': int,  # Maximum tokens for generation
-                'timeout': int,    # Timeout in seconds
-                'sampling': {
-                    'temperature': float  # Controls randomness (0.0 to 1.0)
-                }
-            }
-        :param agent_data_models: list - List of models the agent can use, in order of preference. At least one valid model is required for publication. Each model is a dict with 'name' (e.g., 'gpt-4o' or 'openai/gpt-4o') and optional 'llmConfig' to override defaults. Example:
-            [{'name': str, 'llmConfig': dict}, ...]
-        :param agent_data_resource_pools: Optional[List[Dict]] - List of resource pools organizing tools and helper agents. Optional. Each pool is a dict with 'name' (required), and optional 'tools' and 'agents' lists. Example structure:
-        [
-            {
-                'name': str,
-                'tools': [{'name': str, 'revision': int}, ...],
-                'agents': [{'name': str, 'revision': int}, ...]
-            },
-            ...
-        ]
-        :param automatic_publish: bool - If True, automatically publishes the agent after creation. Defaults to False.
-        :return: dict - JSON response containing the created agent details if successful, otherwise the raw response text.
-        :raises JSONDecodeError: If the response cannot be parsed as JSON.
+        :param name: str - Name of the agent (must be unique within the project, non-empty, and exclude ':' or '/').
+        :param access_scope: str - Access scope of the agent ("public" or "private").
+        :param public_name: str - Public name for the agent, required if access_scope is "public" (must follow domain/library convention, e.g., 'com.example.my-agent').
+        :param job_description: str - Description of the agent's role (optional).
+        :param avatar_image: str - URL for the agent's avatar image (optional).
+        :param description: str - Detailed description of the agent’s purpose (optional).
+        :param agent_data_prompt: dict - Prompt configuration, including 'context', 'instructions', and optional 'examples' (e.g., {'context': str, 'instructions': str, 'examples': [{'inputData': str, 'output': str}]}).
+        :param agent_data_llm_config: dict - LLM configuration (e.g., {'maxTokens': int, 'timeout': int, 'sampling': {'temperature': float}}).
+        :param agent_data_strategy_name: str - Strategy name to be used.
+        :param agent_data_models: list - List of models the agent can use (e.g., [{'name': 'gpt-4o', 'llmConfig': dict}]).
+        :param agent_data_resource_pools: Optional[List[Dict]] - Resource pools for tools and helper agents (e.g., [{'name': str, 'tools': [{'name': str, 'revision': int}], 'agents': [{'name': str, 'revision': int}]}]).
+        :param automatic_publish: bool - Automatically publish the agent after creation (default: False).
+        :return: dict - JSON response containing the created agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises ValueError: If access_scope is invalid.
         """
+        if access_scope is not None and access_scope not in VALID_ACCESS_SCOPES:
+            raise ValueError(f"Access scope must be one of {', '.join(VALID_ACCESS_SCOPES)}.")
+
         data = {
             "agentDefinition": {
                 "name": name,
@@ -117,16 +101,24 @@ class AgentClient(BaseClient):
                 "jobDescription": job_description,
                 "avatarImage": avatar_image,
                 "description": description,
-                "agentData": {
-                    "prompt": agent_data_prompt,
-                    "llmConfig": agent_data_llm_config,
-                    "models": agent_data_models
-                }
             }
         }
-
+        if (
+                agent_data_prompt or agent_data_strategy_name or agent_data_prompt or agent_data_resource_pools or
+                agent_data_llm_config or agent_data_models
+        ):
+            data["agentDefinition"]["agentData"] = {}
         if agent_data_resource_pools is not None:
             data["agentDefinition"]["agentData"]["resourcePools"] = agent_data_resource_pools
+        if agent_data_prompt is not None:
+            data["agentDefinition"]["agentData"]["prompt"] = agent_data_prompt
+        if agent_data_llm_config is not None:
+            data["agentDefinition"]["agentData"]["llmConfig"] = agent_data_llm_config
+        if agent_data_strategy_name is not None:
+            data["agentDefinition"]["agentData"]["strategyName"] = agent_data_strategy_name
+        if agent_data_models is not None:
+            data["agentDefinition"]["agentData"]["models"] = agent_data_models
+        logger.debug(f"Creating agent with data: {data}")
 
         endpoint = CREATE_AGENT_V2
         if automatic_publish:
@@ -134,7 +126,7 @@ class AgentClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         response = self.api_service.post(
@@ -143,37 +135,39 @@ class AgentClient(BaseClient):
             data=data
         )
 
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"create agent for project {self.project_id}")
 
-        return result
 
     def get_agent(
             self,
-            project_id: str,
             agent_id: str,
             revision: str = 0,
             version: int = 0,
             allow_drafts: bool = True
-    ):
+    ) -> dict:
         """
         Retrieves details of a specific agent from the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param agent_id: str - Unique identifier of the agent to retrieve.
-        :param revision: str - Revision of the agent to retrieve. Defaults to 0 (latest revision).
-        :param version: int - Version of the agent to retrieve. Defaults to 0 (latest version).
-        :param allow_drafts: bool - Whether to include draft agents in the retrieval. Defaults to True.
-        :return: dict or str - JSON response containing the agent details if successful, otherwise the raw response text.
+        :param revision: str, optional - Specific revision of the agent to retrieve (default: 0, latest revision).
+        :param version: int, optional - Specific version of the agent to retrieve (default: 0, latest version).
+        :param allow_drafts: bool, optional - Include draft agents in the results (default: True).
+        :return: dict - JSON response containing the agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or agent_id is not provided.
         """
+        if not agent_id:
+            raise MissingRequirementException("agent_id must be specified in order to retrieve the agent")
+
         endpoint = GET_AGENT_V2.format(agentId=agent_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
+        logger.debug(f"Retrieving agent detail with ID {agent_id}")
+
         response = self.api_service.get(
             endpoint=endpoint,
             headers=headers,
@@ -183,63 +177,63 @@ class AgentClient(BaseClient):
                 "allowDrafts": allow_drafts,
             }
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"retrieve agent {agent_id} for project {self.project_id}")
 
-        return result
 
     def create_sharing_link(
             self,
-            project_id: str,
             agent_id: str,
-    ):
+    ) -> dict:
         """
         Creates a sharing link for a specific agent in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param agent_id: str - Unique identifier of the agent for which to create a sharing link.
-        :return: dict or str - JSON response containing the sharing link details if successful, otherwise the raw response text.
+        :return: dict - JSON response containing the sharing link details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or agent_id is not provided.
         """
+        if not agent_id:
+            raise MissingRequirementException("agent_id must be specified in order to create sharing link")
+
         endpoint = CREATE_SHARING_LINK_V2.format(agentId=agent_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
+        logger.debug(f"Creating sharing link for agent with ID {agent_id}")
+
         response = self.api_service.get(
             endpoint=endpoint,
             headers=headers,
             params={}
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"create sharing link for agent {agent_id} in project {self.project_id}")
 
-        return result
 
     def publish_agent_revision(
             self,
-            project_id: str,
             agent_id: str,
             revision: str
-    ):
+    ) -> dict:
         """
         Publishes a specific revision of an agent in the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param agent_id: str - Unique identifier of the agent to publish.
         :param revision: str - Revision of the agent to publish.
-        :return: dict or str - JSON response containing the result of the publish operation if successful, otherwise the raw response text.
+        :return: dict - JSON response containing the result of the publish operation.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
         """
         endpoint = PUBLISH_AGENT_REVISION_V2.format(agentId=agent_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
+        logger.debug(f"Publishing revision {revision} for agent with ID {agent_id}")
+
         response = self.api_service.post(
             endpoint=endpoint,
             headers=headers,
@@ -247,46 +241,42 @@ class AgentClient(BaseClient):
                 "revision": revision,
             }
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"publish revision {revision} for agent {agent_id} in project {self.project_id}")
 
-        return result
 
     def delete_agent(
             self,
-            project_id: str,
             agent_id: str,
-    ):
+    ) -> dict:
         """
         Deletes a specific agent from the specified project.
 
-        :param project_id: str - Unique identifier of the project.
         :param agent_id: str - Unique identifier of the agent to delete.
-        :return: dict or str - JSON response confirming the deletion if successful, otherwise the raw response text.
+        :return: dict - JSON response confirming the deletion.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
         """
         endpoint = DELETE_AGENT_V2.format(agentId=agent_id)
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
+        logger.debug(f"Deleting agent with ID {agent_id}")
+
         response = self.api_service.delete(
             endpoint=endpoint,
             headers=headers,
             data={}
         )
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        if response.status_code != 204:
+            logger.error(f"Unable to delete agent {agent_id} from project {self.project_id}: JSON parsing error (status {response.status_code}). Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to delete agent {agent_id} from project {self.project_id}: {response.text}")
+        else:
+            return {}
 
     def update_agent(
             self,
-            project_id: str,
             agent_id: str,
             name: str,
             access_scope: str,
@@ -296,6 +286,7 @@ class AgentClient(BaseClient):
             description: str,
             agent_data_prompt: dict,
             agent_data_llm_config: dict,
+            agent_data_strategy_name: dict,
             agent_data_models: list,
             agent_data_resource_pools: Optional[List[Dict]] = None,
             automatic_publish: bool = False,
@@ -304,44 +295,27 @@ class AgentClient(BaseClient):
         """
         Updates an existing agent in the specified project or upserts it if specified.
 
-        :param project_id: str - Unique identifier of the project containing the agent.
-        :param agent_id: str - Unique identifier of the agent to update. Required for update operations.
-        :param name: str - Updated name of the agent. Must be non-empty, unique within the project, and exclude ':' or '/' if provided. Optional.
-        :param access_scope: str - Updated access scope of the agent. Must be either 'public' or 'private'. Defaults to 'private'.
-        :param public_name: str - Updated public name of the agent, required if access_scope is 'public'. Must be unique within the installation and follow a domain/library convention (e.g., 'com.example.my-agent'). Only alphanumeric characters, periods, dashes, and underscores are allowed. Optional if access_scope is 'private'.
-        :param job_description: str - Updated description of the agent's role. Optional.
-        :param avatar_image: str - Updated URL from which the agent's avatar image will be loaded. Optional.
-        :param description: str - Updated detailed description of the agent’s purpose. Optional.
-        :param agent_data_prompt: dict - Updated configuration for the agent's prompt. Must include at least 'context' or 'instructions' for publication. Optional fields include 'examples' with 'inputData' and 'output' pairs. Optional. Example structure:
-            {
-                'context': str,
-                'instructions': str,
-                'examples': [{'inputData': str, 'output': str}, ...]
-            }
-        :param agent_data_llm_config: dict - Updated default LLM configuration for the agent. Optional. Example structure:
-            {
-                'maxTokens': int,  # Maximum tokens for generation
-                'timeout': int,    # Timeout in seconds
-                'sampling': {
-                    'temperature': float  # Controls randomness (0.0 to 1.0)
-                }
-            }
-        :param agent_data_models: list - Updated list of models the agent can use, in order of preference. At least one valid model is required for publication. Each model is a dict with 'name' (e.g., 'gpt-4o' or 'openai/gpt-4o') and optional 'llmConfig' to override defaults. Optional. Example:
-            [{'name': str, 'llmConfig': dict}, ...]
-        :param agent_data_resource_pools: Optional[List[Dict]] - Updated list of resource pools organizing tools and helper agents. Optional. Each pool is a dict with 'name' (required), and optional 'tools' and 'agents' lists. Example structure:
-        [
-            {
-                'name': str,
-                'tools': [{'name': str, 'revision': int}, ...],
-                'agents': [{'name': str, 'revision': int}, ...]
-            },
-            ...
-        ]
-        :param automatic_publish: bool - If True, automatically publishes the agent after updating. Defaults to False.
-        :param upsert: bool - If True, creates the agent if it does not exist (upsert); otherwise, only updates an existing agent. Defaults to False.
-        :return: dict - JSON response containing the updated or created agent details if successful, otherwise the raw response text.
-        :raises JSONDecodeError: If the response cannot be parsed as JSON.
+        :param agent_id: str - Unique identifier of the agent to update (required for updates).
+        :param name: str - Updated name of the agent (must be unique, non-empty, exclude ':' or '/'; optional).
+        :param access_scope: str - Updated access scope ("public" or "private").
+        :param public_name: str - Updated public name, required if access_scope is "public" (must follow domain/library convention).
+        :param job_description: str - Updated role description (optional).
+        :param avatar_image: str - Updated avatar image URL (optional).
+        :param description: str - Updated purpose description (optional).
+        :param agent_data_prompt: dict - Updated prompt configuration (e.g., {'context': str, 'instructions': str, 'examples': [{'inputData': str, 'output': str}]}).
+        :param agent_data_llm_config: dict - Updated LLM configuration (e.g., {'maxTokens': int, 'timeout': int, 'sampling': {'temperature': float}}).
+        :param agent_data_strategy_name: str - Updated StrategyName configuration.
+        :param agent_data_models: list - Updated model list (e.g., [{'name': 'gpt-4o', 'llmConfig': dict}]).
+        :param agent_data_resource_pools: Optional[List[Dict]] - Updated resource pools (e.g., [{'name': str, 'tools': [{'name': str, 'revision': int}], 'agents': [{'name': str, 'revision': int}]}]).
+        :param automatic_publish: bool - Automatically publish the agent after updating (default: False).
+        :param upsert: bool - Create the agent if it does not exist (default: False).
+        :return: dict - JSON response containing the updated or created agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises ValueError: If access_scope is invalid.
         """
+        if access_scope is not None and access_scope not in VALID_ACCESS_SCOPES:
+            raise ValueError(f"Access scope must be one of {', '.join(VALID_ACCESS_SCOPES)}.")
+
         data = {
             "agentDefinition": {
                 "name": name,
@@ -350,15 +324,25 @@ class AgentClient(BaseClient):
                 "jobDescription": job_description,
                 "avatarImage": avatar_image,
                 "description": description,
-                "agentData": {
-                    "prompt": agent_data_prompt,
-                    "llmConfig": agent_data_llm_config,
-                    "models": agent_data_models
-                }
             }
         }
+        if (
+                agent_data_prompt or agent_data_strategy_name or agent_data_prompt or agent_data_resource_pools or
+                agent_data_llm_config or agent_data_models
+        ):
+            data["agentDefinition"]["agentData"] = {}
         if agent_data_resource_pools is not None:
             data["agentDefinition"]["agentData"]["resourcePools"] = agent_data_resource_pools
+        if agent_data_prompt is not None:
+            data["agentDefinition"]["agentData"]["prompt"] = agent_data_prompt
+        if agent_data_llm_config is not None:
+            data["agentDefinition"]["agentData"]["llmConfig"] = agent_data_llm_config
+        if agent_data_strategy_name is not None:
+            data["agentDefinition"]["agentData"]["strategyName"] = agent_data_strategy_name
+        if agent_data_models is not None:
+            data["agentDefinition"]["agentData"]["models"] = agent_data_models
+
+        logger.debug(f"Updating agent with ID {agent_id} with data: {data}")
 
         endpoint = UPSERT_AGENT_V2 if upsert else UPDATE_AGENT_V2
         endpoint = endpoint.format(agentId=agent_id) if agent_id else endpoint.format(agentId=name)
@@ -368,7 +352,7 @@ class AgentClient(BaseClient):
 
         headers = {
             "Authorization": self.api_service.token,
-            "ProjectId": project_id
+            "ProjectId": self.project_id
         }
 
         response = self.api_service.put(
@@ -377,9 +361,66 @@ class AgentClient(BaseClient):
             data=data
         )
 
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"update agent {agent_id} in project {self.project_id}")
+
+
+    def export_agent(
+            self,
+            agent_id: str,
+    ) -> dict:
+        """
+        Retrieves details of a specific agent from the specified project.
+
+        :param agent_id: str - Unique identifier of the agent to retrieve.
+        :return: dict - JSON response containing the agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or agent_id is not provided.
+        """
+        if not agent_id:
+            raise MissingRequirementException("agent_id must be specified in order to export the agent")
+
+        endpoint = EXPORT_AGENT_V2.format(agentId=agent_id)
+        headers = {
+            "Authorization": self.api_service.token,
+            "ProjectId": self.project_id
+        }
+
+        logger.debug(f"Exporting agent with ID {agent_id}")
+
+        response = self.api_service.get(
+            endpoint=endpoint,
+            headers=headers,
+        )
+        validate_status_code(response)
+        return parse_json_response(response, f"export agent {agent_id} for project {self.project_id}")
+
+    def import_agent(
+            self,
+            data: dict,
+    ) -> dict:
+        """
+        Retrieves details of a specific agent from the specified project.
+
+        :param data: dict - Agent specification to import
+        :return: dict - JSON response containing the agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or agent_id is not provided.
+        """
+        if not data:
+            raise MissingRequirementException("data for spec must be specified in order to import the agent")
+
+        endpoint = IMPORT_AGENT_V2
+        headers = {
+            "Authorization": self.api_service.token,
+            "ProjectId": self.project_id
+        }
+
+        response = self.api_service.post(
+            endpoint=endpoint,
+            headers=headers,
+            data=data
+        )
+        validate_status_code(response)
+        return parse_json_response(response, f"import agent for project {self.project_id}")
 
-        return result

pygeai/lab/agents/endpoints.py

@@ -6,3 +6,7 @@ PUBLISH_AGENT_REVISION_V2 = "v2/agents/{agentId}/publish-revision"  # POST -> Pu
 DELETE_AGENT_V2 = "v2/agents/{agentId}"  # DEL -> Delete agent
 UPDATE_AGENT_V2 = "v2/agents/{agentId}"  # PUT -> Update agent
 UPSERT_AGENT_V2 = "v2/agents/{agentId}/upsert"  # PUT -> Update or Insert agent
+EXPORT_AGENT_V2 = "v2/agents/{agentId}/export"  # GET -> Export agent
+IMPORT_AGENT_V2 = "v2/agents/import"  # POST -> Import agent
+# EXPORT_AGENT_V4 = "v4/agents/{agentId}/export"  # GET -> Export agent
+# IMPORT_AGENT_V4 = "v4/agents/import"  # POST -> Import agent