pygeai 0.6.0b11__py3-none-any.whl → 0.6.0b13__py3-none-any.whl

pygeai/tests/cli/test_error_handler.py

@@ -70,7 +70,7 @@ class TestErrorHandler(TestCase):
     def test_format_error_basic(self):
         """Test basic error formatting"""
         result = ErrorHandler.format_error("Test Error", "Something went wrong")
-        self.assertIn("ERROR: Something went wrong", result)
+        self.assertIn("ERROR [Test Error]: Something went wrong", result)
         self.assertIn("Run 'geai help' for usage information.", result)
 
     def test_format_error_with_suggestion(self):
@@ -80,7 +80,7 @@ class TestErrorHandler(TestCase):
             "Command not found",
             suggestion="Try using 'help' command"
         )
-        self.assertIn("ERROR: Command not found", result)
+        self.assertIn("ERROR [Test Error]: Command not found", result)
         self.assertIn("→ Try using 'help' command", result)
 
     def test_format_error_without_help(self):
@@ -90,7 +90,7 @@ class TestErrorHandler(TestCase):
             "Critical error",
             show_help=False
         )
-        self.assertIn("ERROR: Critical error", result)
+        self.assertIn("ERROR [Test Error]: Critical error", result)
         self.assertNotIn("Run 'geai help'", result)
 
     def test_find_similar_items_exact_match(self):
@@ -217,7 +217,7 @@ class TestErrorHandler(TestCase):
         ]
         
         for result in results:
-            self.assertIn("ERROR:", result)
+            self.assertIn("ERROR [", result)
             self.assertIn("→", result)
 
 

pygeai/tests/cli/test_geai_driver.py

@@ -68,7 +68,7 @@ class TestCLIDriver(TestCase):
         output = mock_stderr.getvalue()
         
         # Check for standard error format
-        self.assertIn("ERROR:", output)
+        self.assertIn("ERROR [", output)
         self.assertIn("→", output)
         self.assertIn("Run 'geai help' for usage information", output)
 

pygeai/tests/lab/agents/test_mappers.py

@@ -310,4 +310,131 @@ class TestAgentMapper(TestCase):
         sharing_link = AgentMapper.map_to_sharing_link(data)
         self.assertEqual(sharing_link.agent_id, data["agentId"])
         self.assertEqual(sharing_link.api_token, data["apiToken"])
-        self.assertEqual(sharing_link.shared_link, data["sharedLink"])
+        self.assertEqual(sharing_link.shared_link, data["sharedLink"])
+
+    def test_map_to_agent_with_new_fields(self):
+        """Test mapping to Agent with new fields: sharing_scope, permissions, effective_permissions"""
+        data = {
+            "id": "agent123",
+            "name": "TestAgent",
+            "status": "active",
+            "sharingScope": "organization",
+            "permissions": {
+                "chatSharing": "organization",
+                "externalExecution": "none"
+            },
+            "effectivePermissions": {
+                "chatSharing": "organization",
+                "externalExecution": "none"
+            }
+        }
+        agent = AgentMapper.map_to_agent(data)
+        self.assertEqual(agent.id, "agent123")
+        self.assertEqual(agent.name, "TestAgent")
+        self.assertEqual(agent.sharing_scope, "organization")
+        self.assertIsNotNone(agent.permissions)
+        self.assertEqual(agent.permissions.chat_sharing, "organization")
+        self.assertEqual(agent.permissions.external_execution, "none")
+        self.assertIsNotNone(agent.effective_permissions)
+        self.assertEqual(agent.effective_permissions.chat_sharing, "organization")
+        self.assertEqual(agent.effective_permissions.external_execution, "none")
+
+    def test_map_to_agent_with_null_permissions(self):
+        """Test mapping to Agent with null permissions and effective_permissions"""
+        data = {
+            "id": "agent123",
+            "name": "TestAgent",
+            "status": "active",
+            "sharingScope": "private"
+        }
+        agent = AgentMapper.map_to_agent(data)
+        self.assertEqual(agent.id, "agent123")
+        self.assertEqual(agent.sharing_scope, "private")
+        self.assertIsNone(agent.permissions)
+        self.assertIsNone(agent.effective_permissions)
+
+    def test_map_to_permission(self):
+        """Test mapping to Permission"""
+        data = {
+            "chatSharing": "organization",
+            "externalExecution": "project"
+        }
+        permission = AgentMapper._map_to_permission(data)
+        self.assertEqual(permission.chat_sharing, "organization")
+        self.assertEqual(permission.external_execution, "project")
+
+    def test_map_to_permission_null(self):
+        """Test mapping to Permission with None"""
+        permission = AgentMapper._map_to_permission(None)
+        self.assertIsNone(permission)
+
+    def test_map_to_agent_data_with_properties(self):
+        """Test mapping to AgentData with properties field"""
+        data = {
+            "prompt": {"instructions": "Test"},
+            "llmConfig": {"maxTokens": 100},
+            "properties": [
+                {"dataType": "string", "key": "env", "value": "production"},
+                {"dataType": "number", "key": "max_retries", "value": "3"},
+                {"dataType": "boolean", "key": "enabled", "value": "true"}
+            ],
+            "strategyName": "Dynamic Prompting"
+        }
+        agent_data = AgentMapper._map_agent_data(data)
+        self.assertIsNotNone(agent_data.properties)
+        self.assertEqual(len(agent_data.properties), 3)
+        self.assertEqual(agent_data.properties[0].data_type, "string")
+        self.assertEqual(agent_data.properties[0].key, "env")
+        self.assertEqual(agent_data.properties[0].value, "production")
+        self.assertEqual(agent_data.properties[1].data_type, "number")
+        self.assertEqual(agent_data.properties[1].key, "max_retries")
+        self.assertEqual(agent_data.properties[1].value, "3")
+        self.assertEqual(agent_data.properties[2].data_type, "boolean")
+        self.assertEqual(agent_data.properties[2].key, "enabled")
+        self.assertEqual(agent_data.properties[2].value, "true")
+        self.assertEqual(agent_data.strategy_name, "Dynamic Prompting")
+
+    def test_map_to_agent_data_with_null_properties(self):
+        """Test mapping to AgentData with null properties"""
+        data = {
+            "prompt": {"instructions": "Test"},
+            "llmConfig": {"maxTokens": 100}
+        }
+        agent_data = AgentMapper._map_agent_data(data)
+        self.assertIsNone(agent_data.properties)
+        self.assertIsNone(agent_data.strategy_name)
+
+    def test_map_to_property(self):
+        """Test mapping to Property"""
+        data = {
+            "dataType": "string",
+            "key": "environment",
+            "value": "production"
+        }
+        property_obj = AgentMapper._map_to_property(data)
+        self.assertEqual(property_obj.data_type, "string")
+        self.assertEqual(property_obj.key, "environment")
+        self.assertEqual(property_obj.value, "production")
+
+    def test_map_to_property_list(self):
+        """Test mapping to Property list"""
+        data = [
+            {"dataType": "string", "key": "key1", "value": "value1"},
+            {"dataType": "number", "key": "key2", "value": "42"}
+        ]
+        properties = AgentMapper._map_to_property_list(data)
+        self.assertEqual(len(properties), 2)
+        self.assertEqual(properties[0].key, "key1")
+        self.assertEqual(properties[0].value, "value1")
+        self.assertEqual(properties[1].key, "key2")
+        self.assertEqual(properties[1].value, "42")
+
+    def test_map_to_property_list_null(self):
+        """Test mapping to Property list with None"""
+        properties = AgentMapper._map_to_property_list(None)
+        self.assertIsNone(properties)
+
+    def test_map_to_property_list_empty(self):
+        """Test mapping to Property list with empty list"""
+        properties = AgentMapper._map_to_property_list([])
+        self.assertEqual(len(properties), 0)

pygeai/tests/lab/test_models.py

@@ -123,6 +123,7 @@ class TestLabModels(TestCase):
         agent_data_data = {
             "prompt": {"instructions": "Summarize", "inputs": ["text"], "outputs": [{"key": "summary", "description": "Summary"}]},
             "llmConfig": {"maxTokens": 1000, "timeout": 30, "sampling": {"temperature": 0.7, "topK": 40, "topP": 0.9}},
+            "strategyName": "Dynamic Prompting",
             "models": [{"name": "gpt-4"}]
         }
         agent_data = AgentData.model_validate(agent_data_data)
@@ -143,6 +144,7 @@ class TestLabModels(TestCase):
             "agentData": {
                 "prompt": {"instructions": "Summarize", "inputs": ["text"], "outputs": [{"key": "summary", "description": "Summary"}]},
                 "llmConfig": {"maxTokens": 1000, "timeout": 30, "sampling": {"temperature": 0.7, "topK": 40, "topP": 0.9}},
+                "strategyName": "Dynamic Prompting",
                 "models": [{"name": "gpt-4"}]
             }
         }

pygeai/tests/lab/tools/test_clients.py

@@ -68,8 +68,6 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(data['reportEvents'], report_events)
         self.assertEqual(data['parameters'], self.parameters)
         self.assertIn("automaticPublish=true", call_args[1]['endpoint'])
-        headers = call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     def test_create_tool_invalid_scope(self):
         with self.assertRaises(ValueError) as context:
@@ -130,7 +128,6 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_get.assert_called_once_with(
             endpoint=LIST_TOOLS_V2,
-            headers=mock_get.call_args[1]['headers'],
             params={
                 "id": "tool-1",
                 "count": "50",
@@ -140,8 +137,6 @@ class TestToolClient(unittest.TestCase):
                 "allowExternal": True
             }
         )
-        headers = mock_get.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     def test_list_tools_invalid_scope(self):
         with self.assertRaises(ValueError) as context:
@@ -182,15 +177,12 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_get.assert_called_once_with(
             endpoint=GET_TOOL_V2.format(toolId=self.tool_id),
-            headers=mock_get.call_args[1]['headers'],
             params={
                 "revision": "1",
                 "version": 0,
                 "allowDrafts": True
             }
         )
-        headers = mock_get.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     @patch("pygeai.core.services.rest.ApiService.get")
     def test_get_tool_json_decode_error(self, mock_get):
@@ -218,11 +210,8 @@ class TestToolClient(unittest.TestCase):
 
         self.assertEqual(result, {})
         mock_delete.assert_called_once_with(
-            endpoint=DELETE_TOOL_V2.format(toolId=self.tool_id),
-            headers=mock_delete.call_args[1]['headers']
+            endpoint=DELETE_TOOL_V2.format(toolId=self.tool_id)
         )
-        headers = mock_delete.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     @patch("pygeai.core.services.rest.ApiService.delete")
     def test_delete_tool_success_with_name(self, mock_delete):
@@ -235,11 +224,8 @@ class TestToolClient(unittest.TestCase):
 
         self.assertEqual(result, {})
         mock_delete.assert_called_once_with(
-            endpoint=DELETE_TOOL_V2.format(toolId=self.tool_name),
-            headers=mock_delete.call_args[1]['headers']
+            endpoint=DELETE_TOOL_V2.format(toolId=self.tool_name)
         )
-        headers = mock_delete.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     def test_delete_tool_invalid_input(self):
         with self.assertRaises(ValueError) as context:
@@ -298,7 +284,6 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_put.assert_called_once_with(
             endpoint=f"{UPDATE_TOOL_V2.format(toolId=self.tool_id)}?automaticPublish=true",
-            headers=mock_put.call_args[1]['headers'],
             data=mock_put.call_args[1]['data']
         )
         call_args = mock_put.call_args
@@ -313,8 +298,6 @@ class TestToolClient(unittest.TestCase):
         self.assertIsInstance(data['openApiJson'], str)
         self.assertEqual(data['reportEvents'], report_events)
         self.assertEqual(data['parameters'], self.parameters)
-        headers = call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     @patch("pygeai.core.services.rest.ApiService.put")
     def test_update_tool_with_upsert(self, mock_put):
@@ -333,7 +316,6 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_put.assert_called_once_with(
             endpoint=UPSERT_TOOL_V2.format(toolId=self.tool_id),
-            headers=mock_put.call_args[1]['headers'],
             data=mock_put.call_args[1]['data']
         )
 
@@ -393,11 +375,8 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_post.assert_called_once_with(
             endpoint=PUBLISH_TOOL_REVISION_V2.format(toolId=self.tool_id),
-            headers=mock_post.call_args[1]['headers'],
             data={"revision": revision}
         )
-        headers = mock_post.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     @patch("pygeai.core.services.rest.ApiService.post")
     def test_publish_tool_revision_json_decode_error(self, mock_post):
@@ -433,15 +412,12 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_get.assert_called_once_with(
             endpoint=GET_PARAMETER_V2.format(toolPublicName=self.tool_id),
-            headers=mock_get.call_args[1]['headers'],
             params={
                 "revision": "1",
                 "version": 0,
                 "allowDrafts": True
             }
         )
-        headers = mock_get.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     @patch("pygeai.core.services.rest.ApiService.get")
     def test_get_parameter_success_with_public_name(self, mock_get):
@@ -460,7 +436,6 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_get.assert_called_once_with(
             endpoint=GET_PARAMETER_V2.format(toolPublicName=self.tool_public_name),
-            headers=mock_get.call_args[1]['headers'],
             params={
                 "revision": "1",
                 "version": 0,
@@ -501,11 +476,8 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, {})
         mock_post.assert_called_once_with(
             endpoint=SET_PARAMETER_V2.format(toolPublicName=self.tool_id),
-            headers=mock_post.call_args[1]['headers'],
             data={"parameterDefinition": {"parameters": self.parameters}}
         )
-        headers = mock_post.call_args[1]['headers']
-        self.assertEqual(headers['ProjectId'], self.project_id)
 
     @patch("pygeai.core.services.rest.ApiService.post")
     def test_set_parameter_success_with_public_name(self, mock_post):
@@ -520,7 +492,6 @@ class TestToolClient(unittest.TestCase):
         self.assertEqual(result, {})
         mock_post.assert_called_once_with(
             endpoint=SET_PARAMETER_V2.format(toolPublicName=self.tool_public_name),
-            headers=mock_post.call_args[1]['headers'],
             data={"parameterDefinition": {"parameters": self.parameters}}
         )
 

pygeai/tests/organization/test_clients.py

@@ -6,7 +6,8 @@ from pygeai.organization.clients import OrganizationClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException
 from pygeai.organization.endpoints import GET_ASSISTANT_LIST_V1, GET_PROJECT_LIST_V1, GET_PROJECT_V1, CREATE_PROJECT_V1, \
     UPDATE_PROJECT_V1, DELETE_PROJECT_V1, GET_PROJECT_TOKENS_V1, GET_REQUEST_DATA_V1, GET_MEMBERSHIPS_V2, \
-    GET_PROJECT_MEMBERSHIPS_V2, GET_PROJECT_ROLES_V2, GET_PROJECT_MEMBERS_V2, GET_ORGANIZATION_MEMBERS_V2
+    GET_PROJECT_MEMBERSHIPS_V2, GET_PROJECT_ROLES_V2, GET_PROJECT_MEMBERS_V2, GET_ORGANIZATION_MEMBERS_V2, \
+    ADD_PROJECT_MEMBER_V2, CREATE_ORGANIZATION_V2, GET_ORGANIZATION_LIST_V2, DELETE_ORGANIZATION_V2
 
 
 class TestOrganizationClient(unittest.TestCase):
@@ -498,3 +499,181 @@ class TestOrganizationClient(unittest.TestCase):
 
         self.assertEqual(str(context.exception), "Unable to get organization members for organization 'org-123': Invalid JSON response")
 
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_add_project_member_success(self, mock_post):
+        mock_response = mock_post.return_value
+        mock_response.json.return_value = {"status": "invitation sent"}
+        mock_response.status_code = 201
+
+        result = self.client.add_project_member(
+            project_id="proj-123",
+            user_email="newuser@example.com",
+            roles=["Project member", "Project administrator"]
+        )
+
+        mock_post.assert_called_once_with(
+            endpoint=ADD_PROJECT_MEMBER_V2,
+            data={
+                "userEmail": "newuser@example.com",
+                "roles": ["Project member", "Project administrator"]
+            },
+            headers={"project-id": "proj-123"}
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['status'], "invitation sent")
+
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_add_project_member_with_role_guids(self, mock_post):
+        mock_response = mock_post.return_value
+        mock_response.json.return_value = {"status": "invitation sent"}
+        mock_response.status_code = 201
+
+        result = self.client.add_project_member(
+            project_id="proj-123",
+            user_email="newuser@example.com",
+            roles=["guid-1", "guid-2"]
+        )
+
+        mock_post.assert_called_once_with(
+            endpoint=ADD_PROJECT_MEMBER_V2,
+            data={
+                "userEmail": "newuser@example.com",
+                "roles": ["guid-1", "guid-2"]
+            },
+            headers={"project-id": "proj-123"}
+        )
+        self.assertIsNotNone(result)
+
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_add_project_member_json_decode_error(self, mock_post):
+        mock_response = mock_post.return_value
+        mock_response.status_code = 201
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.add_project_member(
+                project_id="proj-123",
+                user_email="newuser@example.com",
+                roles=["Project member"]
+            )
+
+        self.assertEqual(str(context.exception), "Unable to add project member 'newuser@example.com': Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_create_organization_success(self, mock_post):
+        mock_response = mock_post.return_value
+        mock_response.json.return_value = {"organizationId": "org-123", "organizationName": "Test Org"}
+        mock_response.status_code = 201
+
+        result = self.client.create_organization(name="Test Org", administrator_user_email="admin@example.com")
+
+        mock_post.assert_called_once_with(
+            endpoint=CREATE_ORGANIZATION_V2,
+            data={
+                "name": "Test Org",
+                "administratorUserEmail": "admin@example.com"
+            }
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['organizationName'], "Test Org")
+
+    @patch("pygeai.core.services.rest.ApiService.post")
+    def test_create_organization_json_decode_error(self, mock_post):
+        mock_response = mock_post.return_value
+        mock_response.status_code = 201
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.create_organization(name="Test Org", administrator_user_email="admin@example.com")
+
+        self.assertEqual(str(context.exception), "Unable to create organization with name 'Test Org': Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_list_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+            "count": 2,
+            "pages": 1,
+            "organizations": [
+                {"organizationId": "org-1", "organizationName": "Org 1"},
+                {"organizationId": "org-2", "organizationName": "Org 2"}
+            ]
+        }
+        mock_response.status_code = 200
+
+        result = self.client.get_organization_list()
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_ORGANIZATION_LIST_V2,
+            params={"orderDirection": "desc"}
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['count'], 2)
+        self.assertEqual(len(result['organizations']), 2)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_list_with_filters(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {"count": 1, "pages": 1, "organizations": [{"organizationId": "org-1", "organizationName": "Test"}]}
+        mock_response.status_code = 200
+
+        result = self.client.get_organization_list(
+            start_page=1,
+            page_size=10,
+            order_key="name",
+            order_direction="asc",
+            filter_key="name",
+            filter_value="Test"
+        )
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_ORGANIZATION_LIST_V2,
+            params={
+                "startPage": 1,
+                "pageSize": 10,
+                "orderKey": "name",
+                "orderDirection": "asc",
+                "filterKey": "name",
+                "filterValue": "Test"
+            }
+        )
+        self.assertIsNotNone(result)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_list_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_organization_list()
+
+        self.assertEqual(str(context.exception), "Unable to get organization list: Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.delete")
+    def test_delete_organization_success(self, mock_delete):
+        mock_response = mock_delete.return_value
+        mock_response.json.return_value = {"status": "deleted"}
+        mock_response.status_code = 200
+
+        result = self.client.delete_organization(organization_id="org-123")
+
+        mock_delete.assert_called_once_with(endpoint=DELETE_ORGANIZATION_V2.format(organizationId="org-123"))
+        self.assertIsNotNone(result)
+        self.assertEqual(result['status'], "deleted")
+
+    @patch("pygeai.core.services.rest.ApiService.delete")
+    def test_delete_organization_json_decode_error(self, mock_delete):
+        mock_response = mock_delete.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.delete_organization(organization_id="org-123")
+
+        self.assertEqual(str(context.exception), "Unable to delete organization with ID 'org-123': Invalid JSON response")
+

pygeai/tests/organization/test_managers.py

@@ -382,3 +382,43 @@ class TestOrganizationManager(unittest.TestCase):
 
         self.assertIn("Error received while retrieving organization members", str(context.exception))
         mock_get_organization_members.assert_called_once_with(organization_id="org-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.add_project_member")
+    def test_add_project_member(self, mock_add_project_member):
+        mock_response = EmptyResponse(content="Invitation sent successfully")
+        mock_add_project_member.return_value = {}
+
+        with patch.object(ResponseMapper, 'map_to_empty_response', return_value=mock_response):
+            response = self.manager.add_project_member(
+                project_id="proj-123",
+                user_email="newuser@example.com",
+                roles=["Project member"]
+            )
+
+        self.assertIsInstance(response, EmptyResponse)
+        self.assertEqual(response.content, "Invitation sent successfully")
+        mock_add_project_member.assert_called_once_with(
+            project_id="proj-123",
+            user_email="newuser@example.com",
+            roles=["Project member"]
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.add_project_member")
+    def test_add_project_member_error(self, mock_add_project_member):
+        mock_add_project_member.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Invalid role"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.add_project_member(
+                        project_id="proj-123",
+                        user_email="newuser@example.com",
+                        roles=["Invalid role"]
+                    )
+
+        self.assertIn("Error received while adding project member", str(context.exception))
+        mock_add_project_member.assert_called_once_with(
+            project_id="proj-123",
+            user_email="newuser@example.com",
+            roles=["Invalid role"]
+        )

pygeai/tests/snippets/analytics/get_agent_usage_per_user.py

@@ -0,0 +1,16 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_agent_usage_per_user(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print("Agent usage per user:")
+for user in response.agentUsagePerUser:
+    print(f"User: {user.userName or user.userId}")
+    print(f"  Requests: {user.totalRequests}")
+    print(f"  Tokens: {user.totalTokens}")
+    print(f"  Cost: ${user.totalCost:.2f}")
+    print()

pygeai/tests/snippets/analytics/get_agents_created_and_modified.py

@@ -0,0 +1,11 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_agents_created_and_modified(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print(f"Created agents: {response.createdAgents}")
+print(f"Modified agents: {response.modifiedAgents}")

pygeai/tests/snippets/analytics/get_average_cost_per_request.py

@@ -0,0 +1,10 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_average_cost_per_request(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print(f"Average cost per request: ${response.averageCost:.4f}")

pygeai/tests/snippets/analytics/get_overall_error_rate.py

@@ -0,0 +1,10 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_overall_error_rate(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print(f"Overall error rate: {response.errorRate:.2%}")

pygeai/tests/snippets/analytics/get_top_10_agents_by_requests.py

@@ -0,0 +1,12 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_top_10_agents_by_requests(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print("Top 10 agents by requests:")
+for idx, agent in enumerate(response.topAgents, 1):
+    print(f"{idx}. {agent.agentName}: {agent.totalRequests} requests")

pygeai/tests/snippets/analytics/get_total_active_users.py

@@ -0,0 +1,10 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_total_active_users(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print(f"Total active users: {response.totalActiveUsers}")

pygeai/tests/snippets/analytics/get_total_cost.py

@@ -0,0 +1,10 @@
+from pygeai.analytics.managers import AnalyticsManager
+
+manager = AnalyticsManager()
+
+response = manager.get_total_cost(
+    start_date="2025-01-01",
+    end_date="2026-01-31"
+)
+
+print(f"Total cost: ${response.totalCost:.2f}")