cheshirecat-python-sdk 1.2.1__py3-none-any.whl → 1.7.9__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/memory.py

@@ -6,31 +6,19 @@ 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
 

cheshirecat_python_sdk/builders/why.py

@@ -9,7 +9,6 @@ class WhyBuilder(BaseBuilder):
         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
 
     @staticmethod
     def create() -> "WhyBuilder":
@@ -27,14 +26,9 @@ class WhyBuilder(BaseBuilder):
         self.memory = memory
         return self
 
-    def set_model_interactions(self, model_interactions: Dict[str, Any] | None = None) -> "WhyBuilder":
-        self.model_interactions = model_interactions
-        return self
-
     def build(self) -> Why:
         return Why(
             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,10 @@ from cheshirecat_python_sdk.endpoints import (
     MessageEndpoint,
     PluginsEndpoint,
     RabbitHoleEndpoint,
-    SettingsEndpoint,
     UsersEndpoint,
+    UtilsEndpoint,
+    VectorDatabaseEndpoint,
+    HealthCheckEndpoint,
 )
 
 
@@ -51,6 +56,10 @@ class CheshireCatClient:
     def admins(self):
         return AdminsEndpoint(self)
 
+    @property
+    def auth(self):
+        return AuthEndpoint(self)
+
     @property
     def auth_handler(self):
         return AuthHandlerEndpoint(self)
@@ -59,6 +68,10 @@ class CheshireCatClient:
     def chunker(self):
         return ChunkerEndpoint(self)
 
+    @property
+    def conversation(self):
+        return ConversationEndpoint(self)
+
     @property
     def embedder(self):
         return EmbedderEndpoint(self)
@@ -87,10 +100,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,9 @@
 from cheshirecat_python_sdk.endpoints.admins import AdminsEndpoint
+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 +11,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

@@ -3,16 +3,13 @@ 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.models.api.plugins import PluginCollectionOutput, PluginsSettingsOutput, PluginToggleOutput
 from cheshirecat_python_sdk.utils import deserialize, file_attributes
 
 
@@ -21,22 +18,6 @@ class AdminsEndpoint(AbstractEndpoint):
         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.
@@ -47,9 +28,9 @@ class AdminsEndpoint(AbstractEndpoint):
         """
         payload = {"username": username, "password": password}
         if permissions:
-            payload["permissions"] = permissions
+            payload["permissions"] = permissions  # type: ignore
 
-        return self.post_json(self.format_url("/users"), AdminOutput, payload, self.system_id)
+        return self.post_json(self.format_url("/users"), self.system_id, output_class=AdminOutput, payload=payload)
 
     def get_admins(self, limit: int | None = None, skip: int | None = None) -> List[AdminOutput]:
         """
@@ -65,6 +46,8 @@ class AdminsEndpoint(AbstractEndpoint):
             query["skip"] = skip
 
         response = self.get_http_client(self.system_id).get(self.format_url("/users"), params=query)
+        response.raise_for_status()
+
         result = []
         for item in response.json():
             result.append(deserialize(item, AdminOutput))
@@ -76,7 +59,7 @@ class AdminsEndpoint(AbstractEndpoint):
         :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)
+        return self.get(self.format_url(f"/users/{admin_id}"), self.system_id, output_class=AdminOutput)
 
     def put_admin(
         self,
@@ -101,7 +84,7 @@ class AdminsEndpoint(AbstractEndpoint):
         if permissions:
             payload["permissions"] = permissions
 
-        return self.put(self.format_url(f"/users/{admin_id}"), AdminOutput, payload, self.system_id)
+        return self.put(self.format_url(f"/users/{admin_id}"), self.system_id, output_class=AdminOutput, payload=payload)
 
     def delete_admin(self, admin_id: str) -> AdminOutput:
         """
@@ -109,45 +92,7 @@ class AdminsEndpoint(AbstractEndpoint):
         :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)
+        return self.delete(self.format_url(f"/users/{admin_id}"), self.system_id, output_class=AdminOutput)
 
     def get_available_plugins(self, plugin_name: str | None = None) -> PluginCollectionOutput:
         """
@@ -157,8 +102,8 @@ class AdminsEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url("/plugins"),
-            PluginCollectionOutput,
             self.system_id,
+            output_class=PluginCollectionOutput,
             query={"query": plugin_name} if plugin_name else None,
         )
 
@@ -168,7 +113,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("/plugins/upload"),
+                self.system_id,
+                output_class=PluginInstallOutput,
+                payload=payload,
             )
         return result
 
@@ -178,14 +126,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("/plugins/upload/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("/plugins/settings"), self.system_id, output_class=PluginsSettingsOutput)
 
     def get_plugin_settings(self, plugin_id: str) -> PluginSettingsOutput:
         """
@@ -193,7 +146,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"/plugins/settings/{plugin_id}"), self.system_id, output_class=PluginSettingsOutput
+        )
 
     def get_plugin_details(self, plugin_id: str) -> PluginDetailsOutput:
         """
@@ -201,7 +156,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"/plugins/{plugin_id}"), self.system_id, output_class=PluginDetailsOutput)
 
     def delete_plugin(self, plugin_id: str) -> PluginDeleteOutput:
         """
@@ -209,4 +164,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"/plugins/{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"/plugins/toggle/{plugin_id}"),
+            self.system_id,
+            output_class=PluginToggleOutput,
+        )

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

cheshirecat_python_sdk/endpoints/auth_handler.py

@@ -9,7 +9,7 @@ class AuthHandlerEndpoint(AbstractEndpoint):
         super().__init__(client)
         self.prefix = "/auth_handler"
 
-    def get_auth_handlers_settings(self, agent_id: str | None = None) -> FactoryObjectSettingsOutput:
+    def get_auth_handlers_settings(self, agent_id: str) -> FactoryObjectSettingsOutput:
         """
         Get all auth handler settings for the agent with the given ID.
         :param agent_id: The ID of the agent.
@@ -17,11 +17,11 @@ class AuthHandlerEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url("/settings"),
-            FactoryObjectSettingsOutput,
             agent_id,
+            output_class=FactoryObjectSettingsOutput,
         )
 
-    def get_auth_handler_settings(self, auth_handler: str, agent_id: str | None = None) -> FactoryObjectSettingOutput:
+    def get_auth_handler_settings(self, auth_handler: str, agent_id: str) -> FactoryObjectSettingOutput:
         """
         Get the settings for the auth handler with the given name.
         :param auth_handler: The name of the auth handler.
@@ -30,23 +30,23 @@ class AuthHandlerEndpoint(AbstractEndpoint):
         """
         return self.get(
             self.format_url(f"/settings/{auth_handler}"),
-            FactoryObjectSettingOutput,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
         )
 
     def put_auth_handler_settings(
-        self, auth_handler: str, values: Dict[str, Any], agent_id: str | None = None
+        self, auth_handler: str, agent_id: str, values: Dict[str, Any]
     ) -> FactoryObjectSettingOutput:
         """
         Update the settings for the auth handler with the given name.
         :param auth_handler: The name of the auth handler.
-        :param values: The new settings for the auth handler.
         :param agent_id: The ID of the agent.
+        :param values: The new settings for the auth handler.
         :return: FactoryObjectSettingOutput, containing the updated settings for the auth handler.
         """
         return self.put(
             self.format_url(f"/settings/{auth_handler}"),
-            FactoryObjectSettingOutput,
-            values,
             agent_id,
+            output_class=FactoryObjectSettingOutput,
+            payload=values,
         )