cheshirecat-python-sdk 1.2.1__py3-none-any.whl → 1.8.4__py3-none-any.whl

cheshirecat_python_sdk/__init__.py

@@ -1,7 +1,6 @@
 from cheshirecat_python_sdk.client import CheshireCatClient
 from cheshirecat_python_sdk.clients import HttpClient, WSClient
 from cheshirecat_python_sdk.configuration import Configuration
-from cheshirecat_python_sdk.enums import Collection, Role
 
 
 from cheshirecat_python_sdk.builders import *

cheshirecat_python_sdk/builders/__init__.py

@@ -1,3 +1,3 @@
-from cheshirecat_python_sdk.builders.memory import MemoryBuilder, MemoryPointBuilder
+from cheshirecat_python_sdk.builders.memory import MemoryPointBuilder
 from cheshirecat_python_sdk.builders.settings_input import SettingInputBuilder
 from cheshirecat_python_sdk.builders.why import WhyBuilder

cheshirecat_python_sdk/builders/memory.py

@@ -1,38 +1,7 @@
 from typing import Dict, Any
 
 from cheshirecat_python_sdk.builders.base import BaseBuilder
-from cheshirecat_python_sdk.models.dtos import Memory, MemoryPoint
-
-
-class MemoryBuilder(BaseBuilder):
-    def __init__(self):
-        self.episodic: Dict[str, Any] | None = None
-        self.declarative: Dict[str, Any] | None = None
-        self.procedural: Dict[str, Any] | None = None
-
-    @staticmethod
-    def create():
-        return MemoryBuilder()
-
-    def set_episodic(self, episodic: Dict[str, Any] | None = None):
-        self.episodic = episodic or {}
-        return self
-
-    def set_declarative(self, declarative: Dict[str, Any] | None = None):
-        self.declarative = declarative or {}
-        return self
-
-    def set_procedural(self, procedural: Dict[str, Any] | None = None):
-        self.procedural = procedural or {}
-        return self
-
-    def build(self):
-        memory = Memory()
-        memory.episodic = self.episodic
-        memory.declarative = self.declarative
-        memory.procedural = self.procedural
-
-        return memory
+from cheshirecat_python_sdk.models.dtos import MemoryPoint
 
 
 class MemoryPointBuilder(BaseBuilder):

cheshirecat_python_sdk/builders/why.py

@@ -1,15 +1,14 @@
-from typing import Dict, Any
+from typing import List
 
 from cheshirecat_python_sdk.builders.base import BaseBuilder
-from cheshirecat_python_sdk.models.dtos import Memory, Why
+from cheshirecat_python_sdk.models.dtos import Why
 
 
 class WhyBuilder(BaseBuilder):
     def __init__(self):
         self.input: str | None = None
-        self.intermediate_steps: Dict[str, Any] | None = None
-        self.memory: Memory | None = None
-        self.model_interactions: Dict[str, Any] | None = None
+        self.intermediate_steps: List | None = []
+        self.memory: List | None = []
 
     @staticmethod
     def create() -> "WhyBuilder":
@@ -19,16 +18,12 @@ class WhyBuilder(BaseBuilder):
         self.input = input
         return self
 
-    def set_intermediate_steps(self, intermediate_steps: Dict[str, Any] | None = None) -> "WhyBuilder":
-        self.intermediate_steps = intermediate_steps
+    def set_intermediate_steps(self, intermediate_steps: List | None = None) -> "WhyBuilder":
+        self.intermediate_steps = intermediate_steps or []
         return self
 
-    def set_memory(self, memory: Memory) -> "WhyBuilder":
-        self.memory = memory
-        return self
-
-    def set_model_interactions(self, model_interactions: Dict[str, Any] | None = None) -> "WhyBuilder":
-        self.model_interactions = model_interactions
+    def set_memory(self, memory: List | None = None) -> "WhyBuilder":
+        self.memory = memory or []
         return self
 
     def build(self) -> Why:
@@ -36,5 +31,4 @@ class WhyBuilder(BaseBuilder):
             input=self.input,
             intermediate_steps=self.intermediate_steps,
             memory=self.memory,
-            model_interactions=self.model_interactions,
         )

cheshirecat_python_sdk/client.py

@@ -2,8 +2,11 @@ from cheshirecat_python_sdk.clients import HttpClient, WSClient
 from cheshirecat_python_sdk.configuration import Configuration
 from cheshirecat_python_sdk.endpoints import (
     AdminsEndpoint,
+    AuthEndpoint,
     AuthHandlerEndpoint,
     ChunkerEndpoint,
+    ConversationEndpoint,
+    CustomEndpoint,
     EmbedderEndpoint,
     FileManagerEndpoint,
     LargeLanguageModelEndpoint,
@@ -11,8 +14,11 @@ from cheshirecat_python_sdk.endpoints import (
     MessageEndpoint,
     PluginsEndpoint,
     RabbitHoleEndpoint,
-    SettingsEndpoint,
     UsersEndpoint,
+    UtilsEndpoint,
+    VectorDatabaseEndpoint,
+    HealthCheckEndpoint,
+    AgenticWorkflowEndpoint,
 )
 
 
@@ -51,14 +57,26 @@ class CheshireCatClient:
     def admins(self):
         return AdminsEndpoint(self)
 
+    @property
+    def auth(self):
+        return AuthEndpoint(self)
+
     @property
     def auth_handler(self):
         return AuthHandlerEndpoint(self)
 
+    @property
+    def agentic_workflow(self):
+        return AgenticWorkflowEndpoint(self)
+
     @property
     def chunker(self):
         return ChunkerEndpoint(self)
 
+    @property
+    def conversation(self):
+        return ConversationEndpoint(self)
+
     @property
     def embedder(self):
         return EmbedderEndpoint(self)
@@ -87,10 +105,22 @@ class CheshireCatClient:
     def rabbit_hole(self):
         return RabbitHoleEndpoint(self)
 
-    @property
-    def settings(self):
-        return SettingsEndpoint(self)
-
     @property
     def users(self):
         return UsersEndpoint(self)
+
+    @property
+    def utils(self):
+        return UtilsEndpoint(self)
+
+    @property
+    def custom(self):
+        return CustomEndpoint(self)
+
+    @property
+    def vector_database(self):
+        return VectorDatabaseEndpoint(self)
+
+    @property
+    def health_check(self):
+        return HealthCheckEndpoint(self)

cheshirecat_python_sdk/clients/http_client.py

@@ -15,8 +15,9 @@ class HttpClient:
         self.port = port
         self.apikey = apikey
         self.token = None
-        self.user_id = None
         self.agent_id = None
+        self.user_id = None
+        self.chat_id = None
         self.is_https = is_https
         self.headers = {}
 
@@ -38,27 +39,40 @@ class HttpClient:
     def __before_secure_request(self):
         if self.apikey:
             self.headers["Authorization"] = f"Bearer {self.apikey}"
-        if self.user_id:
-            self.headers["user_id"] = self.user_id
         if self.agent_id:
-            self.headers["agent_id"] = self.agent_id
+            self.headers["X-Agent-ID"] = self.agent_id
+        if self.user_id:
+            self.headers["X-User-ID"] = self.user_id
+        if self.chat_id:
+            self.headers["X-Chat-ID"] = self.chat_id
 
     def __before_jwt_request(self):
         if self.token:
             self.headers["Authorization"] = f"Bearer {self.token}"
         if self.agent_id:
-            self.headers["agent_id"] = self.agent_id
+            self.headers["X-Agent-ID"] = self.agent_id
+        if self.chat_id:
+            self.headers["X-Chat-ID"] = self.chat_id
 
-    def get_client(self, agent_id: str | None = None, user_id: str | None = None) -> BaseUrlSession:
+    def get_client(
+        self,
+        agent_id: str | None = None,
+        user_id: str | None = None,
+        chat_id: str | None = None,
+    ) -> BaseUrlSession:
         if not self.apikey and not self.token:
             raise ValueError("You must provide an apikey or a token")
 
-        self.agent_id = agent_id or "agent"
+        self.agent_id = agent_id
         self.user_id = user_id
+        self.chat_id = chat_id
 
         for middleware in self.middlewares:
             middleware()
 
+        return self.get_base_session()
+
+    def get_base_session(self) -> BaseUrlSession:
         session = BaseUrlSession(base_url=self.get_http_uri())
         session.headers = self.headers
 

cheshirecat_python_sdk/clients/websocket_client.py

@@ -22,31 +22,37 @@ class WSClient:
         self.token = token
         return self
 
-    def get_ws_uri(self, agent_id: str | None = None, user_id: str | None = None) -> str:
-        query = {}
-        if self.token:
-            query["token"] = self.token
-        elif self.apikey:
-            query["apikey"] = self.apikey
-        else:
-            raise ValueError("You must provide an apikey or a token")
-
-        if user_id:
-            query["user_id"] = user_id
+    def get_ws_uri(
+        self,
+        agent_id: str,
+        user_id: str,
+        chat_id: str | None = None,
+    ) -> str:
+        query = {"user_id": user_id}
 
         scheme = "wss" if self.is_wss else "ws"
-        path = f"ws/{agent_id}" if agent_id else "ws"
+        path = f"ws/{agent_id}"
+        if chat_id:
+            path += f"/{chat_id}"
+
         query_string = urlencode(query)
         port_suffix = f":{self.port}" if self.port else ""
 
         return f"{scheme}://{self.host}{port_suffix}/{path}?{query_string}"
 
-    async def get_client(self, agent_id: str | None = None, user_id: str | None = None) -> ClientConnection:
-        uri = self.get_ws_uri(agent_id, user_id)
+    async def get_client(self, agent_id: str, user_id: str, chat_id: str | None = None) -> ClientConnection:
+        uri = self.get_ws_uri(agent_id, user_id, chat_id)
         if self.ws_client is None:
             try:
+                if self.token:
+                    headers = {"Authorization": f"Bearer {self.token}"}
+                elif self.apikey:
+                    headers = {"Authorization": f"Bearer {self.apikey}"}
+                else:
+                    raise ValueError("You must provide an apikey or a token")
+
                 # Create a WebSocket connection
-                websocket = await connect(uri, ping_interval=100000, ping_timeout=100000)
+                websocket = await connect(uri, ping_interval=100000, ping_timeout=100000, additional_headers=headers)
                 self.ws_client = websocket
             except InvalidURI as e:
                 raise ValueError(f"Invalid WebSocket URI: {uri}") from e

cheshirecat_python_sdk/configuration.py

@@ -7,5 +7,5 @@ class Configuration(BaseModel):
     """
     host: str = "localhost"
     port: int = 1865
-    auth_key: str = ""
+    auth_key: str | None = None
     secure_connection: bool = False

cheshirecat_python_sdk/endpoints/__init__.py

@@ -1,6 +1,10 @@
 from cheshirecat_python_sdk.endpoints.admins import AdminsEndpoint
+from cheshirecat_python_sdk.endpoints.agentic_workflow import AgenticWorkflowEndpoint
+from cheshirecat_python_sdk.endpoints.auth import AuthEndpoint
 from cheshirecat_python_sdk.endpoints.auth_handler import AuthHandlerEndpoint
 from cheshirecat_python_sdk.endpoints.chunker import ChunkerEndpoint
+from cheshirecat_python_sdk.endpoints.conversation import ConversationEndpoint
+from cheshirecat_python_sdk.endpoints.custom_endpoint import CustomEndpoint
 from cheshirecat_python_sdk.endpoints.embedder import EmbedderEndpoint
 from cheshirecat_python_sdk.endpoints.file_manager import FileManagerEndpoint
 from cheshirecat_python_sdk.endpoints.large_language_model import LargeLanguageModelEndpoint
@@ -8,5 +12,7 @@ from cheshirecat_python_sdk.endpoints.memory import MemoryEndpoint
 from cheshirecat_python_sdk.endpoints.message import MessageEndpoint
 from cheshirecat_python_sdk.endpoints.plugins import PluginsEndpoint
 from cheshirecat_python_sdk.endpoints.rabbit_hole import RabbitHoleEndpoint
-from cheshirecat_python_sdk.endpoints.settings import SettingsEndpoint
 from cheshirecat_python_sdk.endpoints.users import UsersEndpoint
+from cheshirecat_python_sdk.endpoints.utils import UtilsEndpoint
+from cheshirecat_python_sdk.endpoints.vector_database import VectorDatabaseEndpoint
+from cheshirecat_python_sdk.endpoints.health_check import HealthCheckEndpoint

cheshirecat_python_sdk/endpoints/admins.py

@@ -1,153 +1,19 @@
-from typing import List
-
 from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint, MultipartPayload
 from cheshirecat_python_sdk.models.api.admins import (
-    AdminOutput,
-    ResetOutput,
-    CreatedOutput,
     PluginInstallOutput,
     PluginInstallFromRegistryOutput,
     PluginDetailsOutput,
     PluginDeleteOutput,
 )
 from cheshirecat_python_sdk.models.api.nested.plugins import PluginSettingsOutput
-from cheshirecat_python_sdk.models.api.plugins import PluginCollectionOutput, PluginsSettingsOutput
-from cheshirecat_python_sdk.models.api.tokens import TokenOutput
-from cheshirecat_python_sdk.utils import deserialize, file_attributes
+from cheshirecat_python_sdk.models.api.plugins import PluginCollectionOutput, PluginsSettingsOutput, PluginToggleOutput
+from cheshirecat_python_sdk.utils import file_attributes
 
 
 class AdminsEndpoint(AbstractEndpoint):
     def __init__(self, client: "CheshireCatClient"):
         super().__init__(client)
-        self.prefix = "/admins"
-
-    def token(self, username: str, password: str) -> TokenOutput:
-        """
-        This endpoint is used to get a token for the user. The token is used to authenticate the user in the system.
-        When the token expires, the user must request a new token.
-        :param username: The username of the user.
-        :param password: The password of the user.
-        :return: TokenOutput, the token of the user.
-        """
-        response = self.get_http_client().post(
-            self.format_url("/auth/token"),
-            json={"username": username, "password": password},
-        )
-        result = deserialize(response.json(), TokenOutput)
-        self.client.add_token(result.access_token)
-        return result
-
-    def post_admin(self, username: str, password: str, permissions: dict | None = None) -> AdminOutput:
-        """
-        Create a new admin user.
-        :param username: The username of the user.
-        :param password: The password of the user.
-        :param permissions: The permissions of the user.
-        :return: AdminOutput, the details of the user.
-        """
-        payload = {"username": username, "password": password}
-        if permissions:
-            payload["permissions"] = permissions
-
-        return self.post_json(self.format_url("/users"), AdminOutput, payload, self.system_id)
-
-    def get_admins(self, limit: int | None = None, skip: int | None = None) -> List[AdminOutput]:
-        """
-        Get a list of all admin users.
-        :param limit: The maximum number of users to return.
-        :param skip: The number of users to skip.
-        :return: List[AdminOutput], the details
-        """
-        query = {}
-        if limit:
-            query["limit"] = limit
-        if skip:
-            query["skip"] = skip
-
-        response = self.get_http_client(self.system_id).get(self.format_url("/users"), params=query)
-        result = []
-        for item in response.json():
-            result.append(deserialize(item, AdminOutput))
-        return result
-
-    def get_admin(self, admin_id: str) -> AdminOutput:
-        """
-        Get the details of an admin user.
-        :param admin_id: The ID of the user.
-        :return: AdminOutput, the details of the user.
-        """
-        return self.get(self.format_url(f"/users/{admin_id}"), AdminOutput, self.system_id)
-
-    def put_admin(
-        self,
-        admin_id: str,
-        username: str | None = None,
-        password: str | None = None,
-        permissions: dict | None = None,
-    ) -> AdminOutput:
-        """
-        Update the details of an admin user.
-        :param admin_id: The ID of the user.
-        :param username: The new username.
-        :param password: The new password.
-        :param permissions: The new permissions.
-        :return: AdminOutput, the details of the user.
-        """
-        payload = {}
-        if username:
-            payload["username"] = username
-        if password:
-            payload["password"] = password
-        if permissions:
-            payload["permissions"] = permissions
-
-        return self.put(self.format_url(f"/users/{admin_id}"), AdminOutput, payload, self.system_id)
-
-    def delete_admin(self, admin_id: str) -> AdminOutput:
-        """
-        Delete an admin user.
-        :param admin_id: The ID of the user.
-        :return: AdminOutput, the details of the user.
-        """
-        return self.delete(self.format_url(f"/users/{admin_id}"), AdminOutput, self.system_id)
-
-    def post_factory_reset(self) -> ResetOutput:
-        """
-        Reset the system to the factory settings.
-        :return: ResetOutput, the details of the reset.
-        """
-        return self.post_json(self.format_url("/utils/factory/reset/"), ResetOutput, {}, self.system_id)
-
-    def get_agents(self) -> List[str]:
-        """
-        Get a list of all agents.
-        :return: List[str], the IDs of the agents.
-        """
-        return self.get(self.format_url("/utils/agents/"), None, agent_id=self.system_id)
-
-    def post_agent_create(self, agent_id: str | None = None) -> CreatedOutput:
-        """
-        Create a new agent.
-        :param agent_id: The ID of the agent.
-        :return: CreatedOutput, the details of the agent.
-        """
-        return self.post_json(self.format_url("/utils/agent/create/"), CreatedOutput, {}, agent_id)
-
-    def post_agent_reset(self, agent_id: str | None = None) -> ResetOutput:
-        """
-        Reset an agent to the factory settings.
-        :param agent_id: The ID of the agent.
-        :return: ResetOutput, the details of the reset.
-        """
-        return self.post_json(self.format_url("/utils/agent/reset/"), ResetOutput, {}, agent_id)
-
-    def post_agent_destroy(self, agent_id: str | None = None) -> ResetOutput:
-        """
-        Destroy an agent.
-        :param agent_id: The ID of the agent.
-        :return: ResetOutput, the details of the reset.
-        """
-        return self.post_json(self.format_url("/utils/agent/destroy/"), ResetOutput, {}, agent_id)
+        self.prefix = "/plugins"
 
     def get_available_plugins(self, plugin_name: str | None = None) -> PluginCollectionOutput:
         """
@@ -156,9 +22,9 @@ class AdminsEndpoint(AbstractEndpoint):
         :return: PluginCollectionOutput, the details of the plugins.
         """
         return self.get(
-            self.format_url("/plugins"),
-            PluginCollectionOutput,
+            self.format_url("/installed"),
             self.system_id,
+            output_class=PluginCollectionOutput,
             query={"query": plugin_name} if plugin_name else None,
         )
 
@@ -168,7 +34,10 @@ class AdminsEndpoint(AbstractEndpoint):
         with open(path_zip, "rb") as file:
             payload.files = [("file", file_attributes(path_zip, file))]
             result = self.post_multipart(
-                self.format_url("/plugins/upload"), PluginInstallOutput, payload, self.system_id
+                self.format_url("/install/upload"),
+                self.system_id,
+                output_class=PluginInstallOutput,
+                payload=payload,
             )
         return result
 
@@ -178,14 +47,19 @@ class AdminsEndpoint(AbstractEndpoint):
         :param url: The URL of the plugin.
         :return: PluginInstallFromRegistryOutput, the details of the installation.
         """
-        return self.post_json(self.format_url("/plugins/upload/registry"), PluginInstallFromRegistryOutput, {"url": url}, self.system_id)
+        return self.post_json(
+            self.format_url("/install/registry"),
+            self.system_id,
+            output_class=PluginInstallFromRegistryOutput,
+            payload={"url": url},
+        )
 
     def get_plugins_settings(self) -> PluginsSettingsOutput:
         """
         Get the default settings of all the plugins.
         :return: PluginsSettingsOutput, the details of the settings.
         """
-        return self.get(self.format_url("/plugins/settings"), PluginsSettingsOutput, self.system_id)
+        return self.get(self.format_url("/system/settings"), self.system_id, output_class=PluginsSettingsOutput)
 
     def get_plugin_settings(self, plugin_id: str) -> PluginSettingsOutput:
         """
@@ -193,7 +67,9 @@ class AdminsEndpoint(AbstractEndpoint):
         :param plugin_id: The ID of the plugin.
         :return: PluginSettingsOutput, the details of the settings.
         """
-        return self.get(self.format_url(f"/plugins/settings/{plugin_id}"), PluginSettingsOutput, self.system_id)
+        return self.get(
+            self.format_url(f"/system/settings/{plugin_id}"), self.system_id, output_class=PluginSettingsOutput
+        )
 
     def get_plugin_details(self, plugin_id: str) -> PluginDetailsOutput:
         """
@@ -201,7 +77,7 @@ class AdminsEndpoint(AbstractEndpoint):
         :param plugin_id: The ID of the plugin.
         :return: PluginDetailsOutput, the details of the plugin.
         """
-        return self.get(self.format_url(f"/plugins/{plugin_id}"), PluginDetailsOutput, self.system_id)
+        return self.get(self.format_url(f"/system/details/{plugin_id}"), self.system_id, output_class=PluginDetailsOutput)
 
     def delete_plugin(self, plugin_id: str) -> PluginDeleteOutput:
         """
@@ -209,4 +85,16 @@ class AdminsEndpoint(AbstractEndpoint):
         :param plugin_id: The ID of the plugin.
         :return: PluginDeleteOutput, the details of the plugin.
         """
-        return self.delete(self.format_url(f"/plugins/{plugin_id}"), PluginDeleteOutput, self.system_id)
+        return self.delete(self.format_url(f"/uninstall/{plugin_id}"), self.system_id, output_class=PluginDeleteOutput)
+
+    def put_toggle_plugin(self, plugin_id: str) -> PluginToggleOutput:
+        """
+        This endpoint toggles a plugin, on a system level
+        :param plugin_id: The id of the plugin to toggle
+        :return: PluginToggleOutput, the toggled plugin
+        """
+        return self.put(
+            self.format_url(f"/system/toggle/{plugin_id}"),
+            self.system_id,
+            output_class=PluginToggleOutput,
+        )

cheshirecat_python_sdk/endpoints/agentic_workflow.py

@@ -0,0 +1,52 @@
+from typing import Dict, Any
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.factories import FactoryObjectSettingsOutput, FactoryObjectSettingOutput
+
+
+class AgenticWorkflowEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/agentic_workflow"
+
+    def get_agentic_workflows_settings(self, agent_id: str) -> FactoryObjectSettingsOutput:
+        """
+        Get all agentic workflow settings for the agent with the given ID.
+        :param agent_id: The ID of the agent.
+        :return: FactoryObjectSettingsOutput, containing the settings for all agentic workflows.
+        """
+        return self.get(
+            self.format_url("/settings"),
+            agent_id,
+            output_class=FactoryObjectSettingsOutput,
+        )
+
+    def get_agentic_workflow_settings(self, agentic_workflow: str, agent_id: str) -> FactoryObjectSettingOutput:
+        """
+        Get the settings for the agentic workflow with the given name.
+        :param agentic_workflow: The name of the agentic workflow.
+        :param agent_id: The ID of the agent.
+        :return: FactoryObjectSettingOutput, containing the settings for the agentic workflow.
+        """
+        return self.get(
+            self.format_url(f"/settings/{agentic_workflow}"),
+            agent_id,
+            output_class=FactoryObjectSettingOutput,
+        )
+
+    def put_agentic_workflow_settings(
+        self, agentic_workflow: str, agent_id: str, values: Dict[str, Any]
+    ) -> FactoryObjectSettingOutput:
+        """
+        Update the settings for the agentic workflow with the given name.
+        :param agentic_workflow: The name of the agentic workflow.
+        :param agent_id: The ID of the agent.
+        :param values: The new settings for the agentic workflow.
+        :return: FactoryObjectSettingOutput, containing the updated settings for the agentic workflow.
+        """
+        return self.put(
+            self.format_url(f"/settings/{agentic_workflow}"),
+            agent_id,
+            output_class=FactoryObjectSettingOutput,
+            payload=values,
+        )

cheshirecat_python_sdk/endpoints/auth.py

@@ -0,0 +1,54 @@
+from typing import Any
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.tokens import TokenOutput, MeOutput
+from cheshirecat_python_sdk.utils import deserialize
+
+
+class AuthEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/auth"
+
+    def token(self, username: str, password: str) -> TokenOutput:
+        """
+        This endpoint is used to get a token for the user. The token is used to authenticate the user in the system. When
+        the token expires, the user must request a new token.
+        """
+        response = self.get_http_session().post(
+            self.format_url("/token"),
+            json={
+                "username": username,
+                "password": password,
+            },
+        )
+        response.raise_for_status()
+
+        result = deserialize(response.json(), TokenOutput)
+        self.client.add_token(result.access_token)
+
+        return result
+
+    def get_available_permissions(self) -> dict[int | str, Any]:
+        """
+        This endpoint is used to get a list of available permissions in the system. The permissions are used to define
+        the access rights of the users in the system. The permissions are defined by the system administrator.
+        :return array<int|string, Any>, the available permissions
+        """
+        response = self.get_http_client().get(self.format_url("/available-permissions"))
+        response.raise_for_status()
+
+        return response.json()
+
+    def me(self, token: str) -> MeOutput:
+        """
+        This endpoint is used to get the current user information. The user information includes the list of agents
+        the user has access to. This endpoint requires authentication.
+        """
+        self.client.add_token(token)
+
+        response = self.get_http_client().get("/me")
+        response.raise_for_status()
+
+        result = deserialize(response.json(), MeOutput)
+        return result