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

pygeai/proxy/tool.py

@@ -2,39 +2,50 @@ from typing import Any
 import json
 
 
-class MCPTool:
+class ProxiedTool:
     """
-    Represents a tool exposed by an MCP (Multi-Channel Proxy) server.
+    Represents a tool exposed by an ToolServer (Multi-Channel Proxy).
 
     :param server_name: str - Name of the server exposing the tool
     :param name: str - Name of the tool
     :param description: str - Description of the tool's functionality
-    :param publicpreffix: str - Public prefix of the tool
+    :param public_prefix: str - Public prefix of the tool
     :param input_schema: dict[str, Any] - JSON schema defining the expected input for the tool
-    :return: MCPTool - Instance of the MCPTool class
+    :return: ProxiedTool - Instance of the ProxiedTool class
     :raises: ValueError - If any required parameter is invalid or missing
     """
 
     def __init__(
-        self, server_name: str, name: str, description: str, publicpreffix: str, input_schema: dict[str, Any]
+        self,
+        server_name: str,
+        name: str,
+        description: str,
+        public_prefix: str,
+        input_schema: dict[str, Any]
     ) -> None:
         self.server_name: str = server_name
         self.name: str = name
+        self.openai_compatible_name: str = self._get_openai_compatible_name(name)
         self.description: str = description
         self.input_schema: dict[str, Any] = input_schema
-        self.publicpreffix: str = publicpreffix
+        self.public_prefix: str = public_prefix
 
     def get_full_name(self) -> str:
         """Get the full name of the tool."""
-        return f"{self.server_name}__{self.name}"
+        return f"{self.server_name}__{self.openai_compatible_name}"
 
     def is_public(self) -> bool:
         """Check if the tool is public."""
-        return self.publicpreffix is not None
+        return self.public_prefix is not None
 
     def get_public_name(self) -> str:
         """Get the public name of the tool."""
-        return f"{self.publicpreffix}.{self.name if self.server_name in self.publicpreffix else self.get_full_name()}"
+        if not self.public_prefix:
+            return ""
+        if self.server_name in self.public_prefix:
+            return f"{self.public_prefix}.{self.name}"
+        else:
+            return f"{self.public_prefix}.{self.get_full_name()}"
 
     def format_for_llm(self) -> str:
         """Format tool information for LLM.
@@ -43,10 +54,16 @@ class MCPTool:
             A formatted string describing the tool.
         """
         return json.dumps({
-                'type': 'function',
-                'function': {
-                    'name': self.get_full_name(),
-                    'description': self.description or '',
-                    'parameters': self.input_schema
-                }
-            })
+            'type': 'function',
+            'function': {
+                'name': self.get_full_name(),
+                'description': self.description or '',
+                'parameters': self.input_schema
+            }
+        })
+    
+    def _get_openai_compatible_name(self, name: str) -> str:
+        compatible_name = ''.join(
+            c if c.isalnum() or c in '-_' else '_' for c in name.lower()
+        )
+        return compatible_name

pygeai/tests/admin/test_clients.py

@@ -0,0 +1,148 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from json import JSONDecodeError
+
+from pygeai.admin.clients import AdminClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException, APIResponseError, APIResponseError
+
+
+class TestAdminClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.admin.test_clients.TestAdminClient
+    """
+
+    def setUp(self):
+        self.client = AdminClient()
+        self.mock_response = MagicMock()
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_validate_api_token_success(self, mock_get):
+        self.mock_response.json.return_value = {"organizationId": "org-123", "projectId": "proj-123"}
+        self.mock_response.status_code = 200
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.validate_api_token()
+        
+        mock_get.assert_called_once()
+        self.assertEqual(result, {"organizationId": "org-123", "projectId": "proj-123"})
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_validate_api_token_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 500
+        self.mock_response.text = "Invalid response"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.validate_api_token()
+        self.assertIn("API returned an error", str(context.exception))  # "Unable to validate API token", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_authorized_organizations_success(self, mock_get):
+        self.mock_response.json.return_value = {"organizations": ["org1", "org2"]}
+        self.mock_response.status_code = 200
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.get_authorized_organizations()
+        
+        mock_get.assert_called_once()
+        self.assertEqual(result, {"organizations": ["org1", "org2"]})
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_authorized_organizations_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 500
+        self.mock_response.text = "Invalid response"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.get_authorized_organizations()
+        self.assertIn("API returned an error", str(context.exception))  # "Unable to retrieve authorized organizations", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_authorized_projects_by_organization_success(self, mock_get):
+        self.mock_response.json.return_value = {"projects": ["proj1", "proj2"]}
+        self.mock_response.status_code = 200
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.get_authorized_projects_by_organization("org-123")
+        
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        self.assertEqual(call_args[1]['params']['organization'], "org-123")
+        self.assertEqual(result, {"projects": ["proj1", "proj2"]})
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_authorized_projects_by_organization_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 500
+        self.mock_response.text = "Invalid response"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.get_authorized_projects_by_organization("org-123")
+        self.assertIn("API returned an error", str(context.exception))  # "Unable to retrieve authorized projects for organization", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_project_visibility_success(self, mock_get):
+        self.mock_response.json.return_value = {}
+        self.mock_response.status_code = 200
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.get_project_visibility(
+            organization="org-123",
+            project="proj-456",
+            access_token="token-789"
+        )
+        
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        self.assertEqual(call_args[1]['params']['organization'], "org-123")
+        self.assertEqual(call_args[1]['params']['project'], "proj-456")
+        self.assertEqual(call_args[1]['params']['accessToken'], "token-789")
+        self.assertEqual(result, {})
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_project_visibility_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 403
+        self.mock_response.text = "Forbidden"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.get_project_visibility("org-123", "proj-456", "token-789")
+        self.assertIn("API returned an error", str(context.exception))  # "Unable to retrieve project visibility", str(context.exception))
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_project_api_token_success(self, mock_get):
+        self.mock_response.json.return_value = {"apiToken": "api-token-123"}
+        self.mock_response.status_code = 200
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.get_project_api_token(
+            organization="org-123",
+            project="proj-456",
+            access_token="token-789"
+        )
+        
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        self.assertEqual(call_args[1]['params']['organization'], "org-123")
+        self.assertEqual(call_args[1]['params']['project'], "proj-456")
+        self.assertEqual(call_args[1]['params']['accessToken'], "token-789")
+        self.assertEqual(result, {"apiToken": "api-token-123"})
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_project_api_token_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 401
+        self.mock_response.text = "Unauthorized"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(APIResponseError) as context:
+            self.client.get_project_api_token("org-123", "proj-456", "token-789")
+        self.assertIn("API returned an error", str(context.exception))  # "Unable to retrieve project API token", str(context.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_clients.py

@@ -0,0 +1,86 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pygeai.analytics.clients import AnalyticsClient
+
+
+class TestAnalyticsClient(unittest.TestCase):
+
+    def setUp(self):
+        self.client = AnalyticsClient()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_agents_created_and_modified(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"createdAgents": 10, "modifiedAgents": 5}
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_agents_created_and_modified("2024-01-01", "2024-01-31")
+
+        self.assertEqual(result["createdAgents"], 10)
+        self.assertEqual(result["modifiedAgents"], 5)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_total_requests_per_day(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "requestsPerDay": [
+                {"date": "2024-01-01", "totalRequests": 100, "totalRequestsWithError": 5}
+            ]
+        }
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_total_requests_per_day("2024-01-01", "2024-01-31")
+
+        self.assertIn("requestsPerDay", result)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_total_requests_per_day_with_agent_name(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "requestsPerDay": [
+                {"date": "2024-01-01", "totalRequests": 50, "totalRequestsWithError": 2}
+            ]
+        }
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_total_requests_per_day("2024-01-01", "2024-01-31", agent_name="TestAgent")
+
+        self.assertIn("requestsPerDay", result)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_average_cost_per_request(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"averageCost": 2.50}
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_average_cost_per_request("2024-01-01", "2024-01-31")
+
+        self.assertEqual(result["averageCost"], 2.50)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_total_tokens(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "totalInputTokens": 5000,
+            "totalOutputTokens": 3000,
+            "totalTokens": 8000
+        }
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_total_tokens("2024-01-01", "2024-01-31")
+
+        self.assertEqual(result["totalTokens"], 8000)
+        mock_api_service.get.assert_called_once()
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_managers.py

@@ -0,0 +1,94 @@
+import unittest
+from unittest.mock import patch
+from pygeai.core.common.exceptions import APIError
+from pygeai.core.handlers import ErrorHandler
+from pygeai.analytics.managers import AnalyticsManager
+from pygeai.analytics.mappers import AnalyticsResponseMapper
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, TotalRequestsPerDayResponse,
+    AverageCostPerRequestResponse, NumberOfTokensResponse
+)
+
+
+class TestAnalyticsManager(unittest.TestCase):
+
+    def setUp(self):
+        self.manager = AnalyticsManager()
+        self.error_response = {"errors": [{"id": 404, "description": "Not found"}]}
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_agents_created_and_modified")
+    def test_get_agents_created_and_modified(self, mock_get_agents):
+        mock_response = AgentsCreatedAndModifiedResponse(createdAgents=10, modifiedAgents=5)
+        mock_get_agents.return_value = {"createdAgents": 10, "modifiedAgents": 5}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_agents_created_and_modified_response', return_value=mock_response):
+            response = self.manager.get_agents_created_and_modified("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, AgentsCreatedAndModifiedResponse)
+        self.assertEqual(response.createdAgents, 10)
+        self.assertEqual(response.modifiedAgents, 5)
+        mock_get_agents.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31")
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_agents_created_and_modified")
+    def test_get_agents_created_and_modified_error(self, mock_get_agents):
+        mock_get_agents.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_agents_created_and_modified("2024-01-01", "2024-01-31")
+
+        self.assertIn("Error received while retrieving agents created and modified", str(context.exception))
+        mock_get_agents.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31")
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_total_requests_per_day")
+    def test_get_total_requests_per_day(self, mock_get_requests):
+        mock_response = TotalRequestsPerDayResponse(requestsPerDay=[])
+        mock_get_requests.return_value = {"requestsPerDay": []}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_total_requests_per_day_response', return_value=mock_response):
+            response = self.manager.get_total_requests_per_day("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, TotalRequestsPerDayResponse)
+        mock_get_requests.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31", agent_name=None)
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_total_requests_per_day")
+    def test_get_total_requests_per_day_with_agent_name(self, mock_get_requests):
+        mock_response = TotalRequestsPerDayResponse(requestsPerDay=[])
+        mock_get_requests.return_value = {"requestsPerDay": []}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_total_requests_per_day_response', return_value=mock_response):
+            response = self.manager.get_total_requests_per_day("2024-01-01", "2024-01-31", agent_name="TestAgent")
+
+        self.assertIsInstance(response, TotalRequestsPerDayResponse)
+        mock_get_requests.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31", agent_name="TestAgent")
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_average_cost_per_request")
+    def test_get_average_cost_per_request(self, mock_get_cost):
+        mock_response = AverageCostPerRequestResponse(averageCost=2.50)
+        mock_get_cost.return_value = {"averageCost": 2.50}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_average_cost_per_request_response', return_value=mock_response):
+            response = self.manager.get_average_cost_per_request("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, AverageCostPerRequestResponse)
+        self.assertEqual(response.averageCost, 2.50)
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_total_tokens")
+    def test_get_total_tokens(self, mock_get_tokens):
+        mock_response = NumberOfTokensResponse(totalInputTokens=5000, totalOutputTokens=3000, totalTokens=8000)
+        mock_get_tokens.return_value = {
+            "totalInputTokens": 5000,
+            "totalOutputTokens": 3000,
+            "totalTokens": 8000
+        }
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_total_tokens_response', return_value=mock_response):
+            response = self.manager.get_total_tokens("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, NumberOfTokensResponse)
+        self.assertEqual(response.totalTokens, 8000)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_mappers.py

@@ -0,0 +1,84 @@
+import unittest
+from pygeai.analytics.mappers import AnalyticsResponseMapper
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, AgentsCreatedAndModifiedPerDayResponse,
+    FlowsCreatedAndModifiedResponse, AverageCostPerRequestResponse,
+    TotalRequestsPerDayResponse, NumberOfTokensResponse
+)
+
+
+class TestAnalyticsResponseMapper(unittest.TestCase):
+
+    def test_map_to_agents_created_and_modified_response(self):
+        data = {
+            "createdAgents": 15,
+            "modifiedAgents": 8
+        }
+        response = AnalyticsResponseMapper.map_to_agents_created_and_modified_response(data)
+        self.assertIsInstance(response, AgentsCreatedAndModifiedResponse)
+        self.assertEqual(response.createdAgents, 15)
+        self.assertEqual(response.modifiedAgents, 8)
+
+    def test_map_to_agents_created_and_modified_per_day_response(self):
+        data = {
+            "agentsCreatedAndModifiedPerDay": [
+                {"date": "2024-01-01", "createdAgents": 5, "modifiedAgents": 2},
+                {"date": "2024-01-02", "createdAgents": 3, "modifiedAgents": 1}
+            ]
+        }
+        response = AnalyticsResponseMapper.map_to_agents_created_and_modified_per_day_response(data)
+        self.assertIsInstance(response, AgentsCreatedAndModifiedPerDayResponse)
+        self.assertEqual(len(response.agentsCreatedAndModifiedPerDay), 2)
+        self.assertEqual(response.agentsCreatedAndModifiedPerDay[0].date, "2024-01-01")
+
+    def test_map_to_flows_created_and_modified_response(self):
+        data = {
+            "createdFlows": 10,
+            "modifiedFlows": 5
+        }
+        response = AnalyticsResponseMapper.map_to_flows_created_and_modified_response(data)
+        self.assertIsInstance(response, FlowsCreatedAndModifiedResponse)
+        self.assertEqual(response.createdFlows, 10)
+        self.assertEqual(response.modifiedFlows, 5)
+
+    def test_map_to_average_cost_per_request_response(self):
+        data = {
+            "averageCost": 3.25
+        }
+        response = AnalyticsResponseMapper.map_to_average_cost_per_request_response(data)
+        self.assertIsInstance(response, AverageCostPerRequestResponse)
+        self.assertEqual(response.averageCost, 3.25)
+
+    def test_map_to_total_requests_per_day_response(self):
+        data = {
+            "requestsPerDay": [
+                {"date": "2024-01-01", "totalRequests": 150, "totalRequestsWithError": 10},
+                {"date": "2024-01-02", "totalRequests": 200, "totalRequestsWithError": 5}
+            ]
+        }
+        response = AnalyticsResponseMapper.map_to_total_requests_per_day_response(data)
+        self.assertIsInstance(response, TotalRequestsPerDayResponse)
+        self.assertEqual(len(response.requestsPerDay), 2)
+        self.assertEqual(response.requestsPerDay[0].totalRequests, 150)
+
+    def test_map_to_number_of_tokens_response(self):
+        data = {
+            "totalInputTokens": 5000,
+            "totalOutputTokens": 3000,
+            "totalTokens": 8000
+        }
+        response = AnalyticsResponseMapper.map_to_number_of_tokens_response(data)
+        self.assertIsInstance(response, NumberOfTokensResponse)
+        self.assertEqual(response.totalInputTokens, 5000)
+        self.assertEqual(response.totalOutputTokens, 3000)
+        self.assertEqual(response.totalTokens, 8000)
+
+    def test_map_with_missing_fields(self):
+        data = {}
+        response = AnalyticsResponseMapper.map_to_agents_created_and_modified_response(data)
+        self.assertEqual(response.createdAgents, 0)
+        self.assertEqual(response.modifiedAgents, 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_responses.py

@@ -0,0 +1,73 @@
+import unittest
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, AgentActivityPerDayItem, AgentsCreatedAndModifiedPerDayResponse,
+    FlowsCreatedAndModifiedResponse, FlowActivityPerDayItem, FlowsCreatedAndModifiedPerDayResponse,
+    ProcessesCreatedAndModifiedResponse, AgentUsagePerUserItem, AgentUsagePerUserResponse,
+    AverageCostPerRequestResponse, AverageCostPerUserResponse, TotalRequestsPerDayResponse,
+    RequestsPerDayItem
+)
+
+
+class TestAnalyticsResponses(unittest.TestCase):
+
+    def test_agents_created_and_modified_response(self):
+        response = AgentsCreatedAndModifiedResponse(createdAgents=10, modifiedAgents=5)
+        self.assertEqual(response.createdAgents, 10)
+        self.assertEqual(response.modifiedAgents, 5)
+
+    def test_agents_created_and_modified_per_day_response(self):
+        items = [
+            AgentActivityPerDayItem(date="2024-01-01", createdAgents=5, modifiedAgents=2),
+            AgentActivityPerDayItem(date="2024-01-02", createdAgents=3, modifiedAgents=1)
+        ]
+        response = AgentsCreatedAndModifiedPerDayResponse(agentsCreatedAndModifiedPerDay=items)
+        self.assertEqual(len(response.agentsCreatedAndModifiedPerDay), 2)
+        self.assertEqual(response.agentsCreatedAndModifiedPerDay[0].date, "2024-01-01")
+
+    def test_flows_created_and_modified_response(self):
+        response = FlowsCreatedAndModifiedResponse(createdFlows=8, modifiedFlows=3)
+        self.assertEqual(response.createdFlows, 8)
+        self.assertEqual(response.modifiedFlows, 3)
+
+    def test_flows_created_and_modified_per_day_response(self):
+        items = [
+            FlowActivityPerDayItem(date="2024-01-01", createdFlows=4, modifiedFlows=1)
+        ]
+        response = FlowsCreatedAndModifiedPerDayResponse(flowsCreatedAndModifiedPerDay=items)
+        self.assertEqual(len(response.flowsCreatedAndModifiedPerDay), 1)
+
+    def test_processes_created_and_modified_response(self):
+        response = ProcessesCreatedAndModifiedResponse(createdProcesses=12, modifiedProcesses=6)
+        self.assertEqual(response.createdProcesses, 12)
+        self.assertEqual(response.modifiedProcesses, 6)
+
+    def test_agent_usage_per_user_response(self):
+        items = [
+            AgentUsagePerUserItem(userId="user1", userName="John Doe", totalCost=100.50, totalRequests=50, totalTokens=1000)
+        ]
+        response = AgentUsagePerUserResponse(agentUsagePerUser=items)
+        self.assertEqual(len(response.agentUsagePerUser), 1)
+        self.assertEqual(response.agentUsagePerUser[0].userId, "user1")
+        self.assertEqual(response.agentUsagePerUser[0].totalCost, 100.50)
+
+    def test_average_cost_per_request_response(self):
+        response = AverageCostPerRequestResponse(averageCost=2.50)
+        self.assertEqual(response.averageCost, 2.50)
+
+    def test_average_cost_per_user_response(self):
+        response = AverageCostPerUserResponse(averageCost=150.75)
+        self.assertEqual(response.averageCost, 150.75)
+
+    def test_total_requests_per_day_response(self):
+        items = [
+            RequestsPerDayItem(date="2024-01-01", totalRequests=100, totalRequestsWithError=5),
+            RequestsPerDayItem(date="2024-01-02", totalRequests=120, totalRequestsWithError=3)
+        ]
+        response = TotalRequestsPerDayResponse(requestsPerDay=items)
+        self.assertEqual(len(response.requestsPerDay), 2)
+        self.assertEqual(response.requestsPerDay[0].totalRequests, 100)
+        self.assertEqual(response.requestsPerDay[1].totalRequestsWithError, 3)
+
+
+if __name__ == '__main__':
+    unittest.main()