resk-llm 0.1.0__tar.gz

resk-llm-0.1.0/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

resk-llm-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.1
+Name: resk-llm
+Version: 0.1.0
+Summary: Resk-LLM is a robust Python library designed to enhance security and manage context when interacting with OpenAI's language models. It provides a protective layer for API calls, safeguarding against common vulnerabilities and ensuring optimal performance.
+Home-page: https://github.com/Resk-Security/Resk-LLM
+Author: Resk
+Author-email: nielzac@proton.me
+License: MIT License
+        
+        Copyright (c) 
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+
+# LLM Protector for OpenAI
+
+LLM Protector is a Python library designed to secure calls to the OpenAI API by protecting against context overflow attacks, cleaning inputs, and managing a sliding context window.
+
+## Installation
+
+```
+pip install resk ##soon avalailble  
+```
+Instead use : 
+```
+git clone  
+```
+## Usage
+
+```python
+from openai import OpenAI
+from llm_protector import OpenAIProtector
+
+# Initialize the OpenAI client
+client = OpenAI(api_key="your-api-key")
+
+# Create a protector instance
+protector = OpenAIProtector(model="gpt-4o-mini", preserved_prompts=2, reserved_tokens=1000)
+
+# Example usage with OpenAI API
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "Hello, can you help me?"},
+    {"role": "assistant", "content": "Of course! How can I assist you today?"},
+    {"role": "user", "content": "I'd like to learn more about Python programming."}
+]
+
+response = protector.protect_openai_call(
+    client.chat.completions.create,
+    model="gpt-4o-mini",
+    messages=messages
+)
+
+print(response.choices[0].message.content)
+```
+
+## Features
+
+### Model Selection
+
+You can specify the model when initializing the protector:
+
+```python
+protector = OpenAIProtector(model="gpt-4o-mini")
+```
+
+To get the list of available models:
+
+```python
+print(OpenAIProtector.get_available_models())
+```
+
+To get information about a specific model:
+
+```python
+print(OpenAIProtector.get_model_info("gpt-4o-mini"))
+```
+
+### Special Tokens
+
+The protector uses a predefined list of OpenAI special tokens for input sanitization. You can view and modify this list if necessary.
+
+To get the current list of special tokens:
+
+```python
+print(OpenAIProtector.get_special_tokens())
+```
+
+To update the list of special tokens:
+
+```python
+new_tokens = {
+    "general": ["<|endoftext|>", "<|fim_prefix|>"],
+    "chat": ["<|im_start|>user", "<|im_start|>assistant"]
+}
+OpenAIProtector.update_special_tokens(new_tokens)
+```
+
+### Context Management
+
+The protector automatically manages a sliding context for long conversations. You can specify the number of prompts to preserve and the number of reserved tokens during initialization:
+
+```python
+protector = OpenAIProtector(model="gpt-4o-mini", preserved_prompts=2, reserved_tokens=1000)
+```
+
+- `preserved_prompts`: Number of messages at the beginning of the conversation to always preserve (default 2, typically the system prompt and the first user message).
+- `reserved_tokens`: Number of tokens reserved for preserved messages and the last message (default 1000).
+
+The protector:
+- Cleans messages by removing non-UTF-8 characters and special tokens.
+- Automatically closes open HTML tags.
+- Escapes special HTML characters.
+- Truncates messages that are too long if necessary.
+- Removes the oldest messages to respect the model's context limit.
+
+## Security
+
+The protector automatically sanitizes all inputs and manages the context when using the `protect_openai_call` method. Always use this method for your OpenAI API calls to benefit from all protections.
+
+```
+
+## License
+
+This project is licensed under a Custom Open Source License. See the [LICENSE](LICENSE) file for full details. Key points:
+
+- Free for commercial and non-commercial use
+- Modifications must be documented and attributed
+- Paid versions based on this code are subject to royalties
+- The original source must be cited in all derivative works

resk-llm-0.1.0/README.md

@@ -0,0 +1,116 @@
+# LLM Protector for OpenAI
+
+LLM Protector is a Python library designed to secure calls to the OpenAI API by protecting against context overflow attacks, cleaning inputs, and managing a sliding context window.
+
+## Installation
+
+```
+pip install resk ##soon avalailble  
+```
+Instead use : 
+```
+git clone  
+```
+## Usage
+
+```python
+from openai import OpenAI
+from llm_protector import OpenAIProtector
+
+# Initialize the OpenAI client
+client = OpenAI(api_key="your-api-key")
+
+# Create a protector instance
+protector = OpenAIProtector(model="gpt-4o-mini", preserved_prompts=2, reserved_tokens=1000)
+
+# Example usage with OpenAI API
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "Hello, can you help me?"},
+    {"role": "assistant", "content": "Of course! How can I assist you today?"},
+    {"role": "user", "content": "I'd like to learn more about Python programming."}
+]
+
+response = protector.protect_openai_call(
+    client.chat.completions.create,
+    model="gpt-4o-mini",
+    messages=messages
+)
+
+print(response.choices[0].message.content)
+```
+
+## Features
+
+### Model Selection
+
+You can specify the model when initializing the protector:
+
+```python
+protector = OpenAIProtector(model="gpt-4o-mini")
+```
+
+To get the list of available models:
+
+```python
+print(OpenAIProtector.get_available_models())
+```
+
+To get information about a specific model:
+
+```python
+print(OpenAIProtector.get_model_info("gpt-4o-mini"))
+```
+
+### Special Tokens
+
+The protector uses a predefined list of OpenAI special tokens for input sanitization. You can view and modify this list if necessary.
+
+To get the current list of special tokens:
+
+```python
+print(OpenAIProtector.get_special_tokens())
+```
+
+To update the list of special tokens:
+
+```python
+new_tokens = {
+    "general": ["<|endoftext|>", "<|fim_prefix|>"],
+    "chat": ["<|im_start|>user", "<|im_start|>assistant"]
+}
+OpenAIProtector.update_special_tokens(new_tokens)
+```
+
+### Context Management
+
+The protector automatically manages a sliding context for long conversations. You can specify the number of prompts to preserve and the number of reserved tokens during initialization:
+
+```python
+protector = OpenAIProtector(model="gpt-4o-mini", preserved_prompts=2, reserved_tokens=1000)
+```
+
+- `preserved_prompts`: Number of messages at the beginning of the conversation to always preserve (default 2, typically the system prompt and the first user message).
+- `reserved_tokens`: Number of tokens reserved for preserved messages and the last message (default 1000).
+
+The protector:
+- Cleans messages by removing non-UTF-8 characters and special tokens.
+- Automatically closes open HTML tags.
+- Escapes special HTML characters.
+- Truncates messages that are too long if necessary.
+- Removes the oldest messages to respect the model's context limit.
+
+## Security
+
+The protector automatically sanitizes all inputs and manages the context when using the `protect_openai_call` method. Always use this method for your OpenAI API calls to benefit from all protections.
+
+```
+
+## License
+
+This project is licensed under a Custom Open Source License. See the [LICENSE](LICENSE) file for full details. Key points:
+
+- Free for commercial and non-commercial use
+- Modifications must be documented and attributed
+- Paid versions based on this code are subject to royalties
+- The original source must be cited in all derivative works

resk-llm-0.1.0/resk-llm/__init__.py

@@ -0,0 +1,3 @@
+from .openai_protector import OpenAIProtector
+
+__version__ = "0.1.0"

resk-llm-0.1.0/resk-llm/openai_protector.py

@@ -0,0 +1,82 @@
+import re
+import html
+from typing import List, Dict, Any, Callable
+
+from resk.resk_models import RESK_MODELS
+from resk.resk_openai_tokens import OPENAI_SPECIAL_TOKENS
+
+class OpenAIProtector:
+    def __init__(self, model: str = "gpt-4o", max_context_length: int = None, reserved_tokens: int = 1000, preserved_prompts: int = 2):
+        self.model = model
+        self.model_info = RESK_MODELS.get(model, RESK_MODELS["gpt-4o"])
+        self.max_context_length = max_context_length or self.model_info["context_window"]
+        self.max_output_tokens = self.model_info["max_output_tokens"]
+        self.reserved_tokens = reserved_tokens
+        self.preserved_prompts = preserved_prompts
+        self.special_tokens = set(OPENAI_SPECIAL_TOKENS["general"] + OPENAI_SPECIAL_TOKENS["chat"])
+
+    def sanitize_input(self, text: str) -> str:
+        text = text.encode('utf-8', errors='ignore').decode('utf-8')
+        for token in self.special_tokens:
+            text = text.replace(token, "")
+        text = self._close_html_tags(text)
+        return html.escape(text)
+
+    def _close_html_tags(self, text: str) -> str:
+        opened_tags = []
+        for match in re.finditer(r'<(\w+)[^>]*>', text):
+            tag = match.group(1)
+            if tag.lower() not in ['br', 'hr', 'img']:
+                opened_tags.append(tag)
+        for tag in reversed(opened_tags):
+            text += f'</{tag}>'
+        return text
+
+    def _truncate_text(self, text: str) -> str:
+        max_chars = self.max_context_length * 4  # Estimation grossière : 1 token ≈ 4 caractères
+        return text[:max_chars] if len(text) > max_chars else text
+
+    def manage_sliding_context(self, messages: List[Dict[str, str]]) -> List[Dict[str, str]]:
+        total_tokens = sum(len(msg['content'].split()) for msg in messages)
+        if total_tokens <= self.max_context_length:
+            return messages
+
+        preserved_messages = messages[:self.preserved_prompts]
+        remaining_messages = messages[self.preserved_prompts:]
+
+        available_tokens = self.max_context_length - self.reserved_tokens
+        preserved_tokens = sum(len(msg['content'].split()) for msg in preserved_messages)
+        available_tokens -= preserved_tokens
+
+        while remaining_messages and sum(len(msg['content'].split()) for msg in remaining_messages) > available_tokens:
+            remaining_messages.pop(0)
+
+        return preserved_messages + remaining_messages
+
+    def protect_openai_call(self, api_function: Callable, *args: Any, **kwargs: Any) -> Any:
+        sanitized_args = [self.sanitize_input(arg) if isinstance(arg, str) else arg for arg in args]
+        sanitized_kwargs = {k: self.sanitize_input(v) if isinstance(v, str) else v for k, v in kwargs.items()}
+        
+        if 'messages' in sanitized_kwargs:
+            sanitized_kwargs['messages'] = self.manage_sliding_context(sanitized_kwargs['messages'])
+        
+        sanitized_kwargs['model'] = self.model_info.get('version', self.model)
+        
+        return api_function(*sanitized_args, **sanitized_kwargs)
+
+    @classmethod
+    def get_available_models(cls) -> List[str]:
+        return list(RESK_MODELS.keys())
+
+    @classmethod
+    def get_model_info(cls, model: str) -> Dict[str, Any]:
+        return RESK_MODELS.get(model, None)
+    
+    @classmethod
+    def get_special_tokens(cls) -> Dict[str, List[str]]:
+        return OPENAI_SPECIAL_TOKENS
+
+    @classmethod
+    def update_special_tokens(cls, new_tokens: Dict[str, List[str]]) -> None:
+        global OPENAI_SPECIAL_TOKENS
+        OPENAI_SPECIAL_TOKENS = new_tokens

resk-llm-0.1.0/resk-llm/resk_context_manager.py

@@ -0,0 +1,40 @@
+class ContextManager:
+    def __init__(self, model_info, preserved_prompts=2, reserved_tokens=1000):
+        self.max_context_length = model_info["context_window"]
+        self.preserved_prompts = preserved_prompts
+        self.reserved_tokens = reserved_tokens
+
+    def clean_message(self, message):
+        return ' '.join(message.split())  # Supprime les espaces multiples, tabulations et sauts de ligne
+
+    def truncate_message(self, message, available_tokens):
+        words = message.split()
+        return ' '.join(words[:available_tokens])
+
+    def manage_sliding_context(self, messages):
+        cleaned_messages = [{'role': msg['role'], 'content': self.clean_message(msg['content'])} for msg in messages]
+        total_tokens = sum(len(msg['content'].split()) for msg in cleaned_messages)
+        
+        if total_tokens <= self.max_context_length:
+            return cleaned_messages
+
+        preserved_messages = cleaned_messages[:self.preserved_prompts]
+        remaining_messages = cleaned_messages[self.preserved_prompts:]
+
+        available_tokens = self.max_context_length - self.reserved_tokens
+        preserved_tokens = sum(len(msg['content'].split()) for msg in preserved_messages)
+        available_tokens -= preserved_tokens
+
+        while remaining_messages and available_tokens > 0:
+            message = remaining_messages.pop(0)
+            message_tokens = len(message['content'].split())
+            
+            if message_tokens > available_tokens:
+                truncated_content = self.truncate_message(message['content'], available_tokens)
+                preserved_messages.append({'role': message['role'], 'content': truncated_content})
+                break
+            else:
+                preserved_messages.append(message)
+                available_tokens -= message_tokens
+
+        return preserved_messages

resk-llm-0.1.0/resk-llm/resk_models.py

@@ -0,0 +1,124 @@
+
+RESK_MODELS = {
+    # GPT-4o models
+    "gpt-4o": {
+        "description": "Our high-intelligence flagship model for complex, multi-step tasks. GPT-4o is cheaper and faster than GPT-4 Turbo.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Oct 2023",
+        "version": "gpt-4o-2024-05-13"
+    },
+    "gpt-4o-2024-05-13": {
+        "description": "gpt-4o currently points to this version.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Oct 2023"
+    },
+    "gpt-4o-2024-08-06": {
+        "description": "Latest snapshot that supports Structured Outputs",
+        "context_window": 128000,
+        "max_output_tokens": 16384,
+        "training_data": "Up to Oct 2023"
+    },
+    "chatgpt-4o-latest": {
+        "description": "Dynamic model continuously updated to the current version of GPT-4o in ChatGPT. Intended for research and evaluation.",
+        "context_window": 128000,
+        "max_output_tokens": 16384,
+        "training_data": "Up to Oct 2023"
+    },
+    
+    # GPT-4o mini models
+    "gpt-4o-mini": {
+        "description": "Our affordable and intelligent small model for fast, lightweight tasks. GPT-4o mini is cheaper and more capable than GPT-3.5 Turbo.",
+        "context_window": 128000,
+        "max_output_tokens": 16384,
+        "training_data": "Up to Oct 2023",
+        "version": "gpt-4o-mini-2024-07-18"
+    },
+    "gpt-4o-mini-2024-07-18": {
+        "description": "gpt-4o-mini currently points to this version.",
+        "context_window": 128000,
+        "max_output_tokens": 16384,
+        "training_data": "Up to Oct 2023"
+    },
+    
+    # GPT-4 Turbo and GPT-4 models
+    "gpt-4-turbo": {
+        "description": "The latest GPT-4 Turbo model with vision capabilities. Vision requests can now use JSON mode and function calling.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Dec 2023",
+        "version": "gpt-4-turbo-2024-04-09"
+    },
+    "gpt-4-turbo-2024-04-09": {
+        "description": "GPT-4 Turbo with Vision model. Vision requests can now use JSON mode and function calling.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Dec 2023"
+    },
+    "gpt-4-turbo-preview": {
+        "description": "GPT-4 Turbo preview model.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Dec 2023",
+        "version": "gpt-4-0125-preview"
+    },
+    "gpt-4-0125-preview": {
+        "description": "GPT-4 Turbo preview model intended to reduce cases of 'laziness' where the model doesn't complete a task.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Dec 2023"
+    },
+    "gpt-4-1106-preview": {
+        "description": "GPT-4 Turbo preview model featuring improved instruction following, JSON mode, reproducible outputs, parallel function calling, and more.",
+        "context_window": 128000,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Apr 2023"
+    },
+    "gpt-4": {
+        "description": "Currently points to gpt-4-0613.",
+        "context_window": 8192,
+        "max_output_tokens": 8192,
+        "training_data": "Up to Sep 2021",
+        "version": "gpt-4-0613"
+    },
+    "gpt-4-0613": {
+        "description": "Snapshot of gpt-4 from June 13th 2023 with improved function calling support.",
+        "context_window": 8192,
+        "max_output_tokens": 8192,
+        "training_data": "Up to Sep 2021"
+    },
+    "gpt-4-0314": {
+        "description": "Legacy Snapshot of gpt-4 from March 14th 2023.",
+        "context_window": 8192,
+        "max_output_tokens": 8192,
+        "training_data": "Up to Sep 2021"
+    },
+    
+    # GPT-3.5 Turbo models
+    "gpt-3.5-turbo": {
+        "description": "Currently points to gpt-3.5-turbo-0125.",
+        "context_window": 16385,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Sep 2021",
+        "version": "gpt-3.5-turbo-0125"
+    },
+    "gpt-3.5-turbo-0125": {
+        "description": "The latest GPT-3.5 Turbo model with higher accuracy at responding in requested formats and a fix for a bug which caused a text encoding issue for non-English language function calls.",
+        "context_window": 16385,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Sep 2021"
+    },
+    "gpt-3.5-turbo-1106": {
+        "description": "GPT-3.5 Turbo model with improved instruction following, JSON mode, reproducible outputs, parallel function calling, and more.",
+        "context_window": 16385,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Sep 2021"
+    },
+    "gpt-3.5-turbo-instruct": {
+        "description": "Similar capabilities as GPT-3 era models. Compatible with legacy Completions endpoint and not Chat Completions.",
+        "context_window": 4096,
+        "max_output_tokens": 4096,
+        "training_data": "Up to Sep 2021"
+    }
+}

resk-llm-0.1.0/resk-llm/resk_openai_tokens.py

@@ -0,0 +1,26 @@
+# resk_openai_tokens.py
+
+OPENAI_SPECIAL_TOKENS = {
+    "general": [
+        "<|endoftext|>",
+        "<|fim_prefix|>",
+        "<|fim_middle|>",
+        "<|fim_suffix|>",
+        "<|endofprompt|>",
+        "<s>",
+        "</s>",
+        "<|im_start|>",
+        "<|im_end|>",
+        "<|im_sep|>",
+        "[/INST]",
+        "SYS",
+        "[INST]",
+        
+
+    ],
+    "chat": [
+        "<|im_start|>user",
+        "<|im_start|>assistant",
+        "<|im_start|>system",
+    ]
+}

resk-llm-0.1.0/resk-llm/resk_protector.py

@@ -0,0 +1,42 @@
+from resk_models import RESK_MODELS
+from resk_openai_tokens import OPENAI_SPECIAL_TOKENS
+from resk_context_manager import ContextManager
+
+import html
+
+class ReskProtector:
+    def __init__(self, model="gpt-4o", preserved_prompts=2, reserved_tokens=1000):
+        self.model = model
+        self.model_info = RESK_MODELS.get(model, RESK_MODELS["gpt-4o"])
+        self.special_tokens = set(OPENAI_SPECIAL_TOKENS["general"] + OPENAI_SPECIAL_TOKENS["chat"])
+        self.context_manager = ContextManager(self.model_info, preserved_prompts, reserved_tokens)
+
+    def sanitize_input(self, text):
+        text = text.encode('utf-8', errors='ignore').decode('utf-8')
+        for token in self.special_tokens:
+            text = text.replace(token, "")
+        text = self._close_html_tags(text)
+        text = html.escape(text)
+        return text
+
+    def _close_html_tags(self, text):
+        # Implémentation de la fermeture des balises HTML
+        pass
+
+    def protect_openai_call(self, api_function, *args, **kwargs):
+        sanitized_args = [self.sanitize_input(arg) if isinstance(arg, str) else arg for arg in args]
+        sanitized_kwargs = {k: self.sanitize_input(v) if isinstance(v, str) else v for k, v in kwargs.items()}
+        
+        if 'messages' in sanitized_kwargs:
+            sanitized_kwargs['messages'] = self.context_manager.manage_sliding_context(sanitized_kwargs['messages'])
+        
+        return api_function(*sanitized_args, **sanitized_kwargs)
+
+    @classmethod
+    def get_special_tokens(cls):
+        return OPENAI_SPECIAL_TOKENS
+
+    @classmethod
+    def update_special_tokens(cls, new_tokens):
+        global OPENAI_SPECIAL_TOKENS
+        OPENAI_SPECIAL_TOKENS = new_tokens

resk-llm-0.1.0/resk_llm.egg-info/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.1
+Name: resk-llm
+Version: 0.1.0
+Summary: Resk-LLM is a robust Python library designed to enhance security and manage context when interacting with OpenAI's language models. It provides a protective layer for API calls, safeguarding against common vulnerabilities and ensuring optimal performance.
+Home-page: https://github.com/Resk-Security/Resk-LLM
+Author: Resk
+Author-email: nielzac@proton.me
+License: MIT License
+        
+        Copyright (c) 
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+
+# LLM Protector for OpenAI
+
+LLM Protector is a Python library designed to secure calls to the OpenAI API by protecting against context overflow attacks, cleaning inputs, and managing a sliding context window.
+
+## Installation
+
+```
+pip install resk ##soon avalailble  
+```
+Instead use : 
+```
+git clone  
+```
+## Usage
+
+```python
+from openai import OpenAI
+from llm_protector import OpenAIProtector
+
+# Initialize the OpenAI client
+client = OpenAI(api_key="your-api-key")
+
+# Create a protector instance
+protector = OpenAIProtector(model="gpt-4o-mini", preserved_prompts=2, reserved_tokens=1000)
+
+# Example usage with OpenAI API
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "Hello, can you help me?"},
+    {"role": "assistant", "content": "Of course! How can I assist you today?"},
+    {"role": "user", "content": "I'd like to learn more about Python programming."}
+]
+
+response = protector.protect_openai_call(
+    client.chat.completions.create,
+    model="gpt-4o-mini",
+    messages=messages
+)
+
+print(response.choices[0].message.content)
+```
+
+## Features
+
+### Model Selection
+
+You can specify the model when initializing the protector:
+
+```python
+protector = OpenAIProtector(model="gpt-4o-mini")
+```
+
+To get the list of available models:
+
+```python
+print(OpenAIProtector.get_available_models())
+```
+
+To get information about a specific model:
+
+```python
+print(OpenAIProtector.get_model_info("gpt-4o-mini"))
+```
+
+### Special Tokens
+
+The protector uses a predefined list of OpenAI special tokens for input sanitization. You can view and modify this list if necessary.
+
+To get the current list of special tokens:
+
+```python
+print(OpenAIProtector.get_special_tokens())
+```
+
+To update the list of special tokens:
+
+```python
+new_tokens = {
+    "general": ["<|endoftext|>", "<|fim_prefix|>"],
+    "chat": ["<|im_start|>user", "<|im_start|>assistant"]
+}
+OpenAIProtector.update_special_tokens(new_tokens)
+```
+
+### Context Management
+
+The protector automatically manages a sliding context for long conversations. You can specify the number of prompts to preserve and the number of reserved tokens during initialization:
+
+```python
+protector = OpenAIProtector(model="gpt-4o-mini", preserved_prompts=2, reserved_tokens=1000)
+```
+
+- `preserved_prompts`: Number of messages at the beginning of the conversation to always preserve (default 2, typically the system prompt and the first user message).
+- `reserved_tokens`: Number of tokens reserved for preserved messages and the last message (default 1000).
+
+The protector:
+- Cleans messages by removing non-UTF-8 characters and special tokens.
+- Automatically closes open HTML tags.
+- Escapes special HTML characters.
+- Truncates messages that are too long if necessary.
+- Removes the oldest messages to respect the model's context limit.
+
+## Security
+
+The protector automatically sanitizes all inputs and manages the context when using the `protect_openai_call` method. Always use this method for your OpenAI API calls to benefit from all protections.
+
+```
+
+## License
+
+This project is licensed under a Custom Open Source License. See the [LICENSE](LICENSE) file for full details. Key points:
+
+- Free for commercial and non-commercial use
+- Modifications must be documented and attributed
+- Paid versions based on this code are subject to royalties
+- The original source must be cited in all derivative works

resk-llm-0.1.0/resk_llm.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENCE.txt
+README.md
+setup.py
+resk-llm/__init__.py
+resk-llm/openai_protector.py
+resk-llm/resk_context_manager.py
+resk-llm/resk_models.py
+resk-llm/resk_openai_tokens.py
+resk-llm/resk_protector.py
+resk_llm.egg-info/PKG-INFO
+resk_llm.egg-info/SOURCES.txt
+resk_llm.egg-info/dependency_links.txt
+resk_llm.egg-info/requires.txt
+resk_llm.egg-info/top_level.txt
+tests/test_openai_protector.py.py

resk-llm-0.1.0/resk_llm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

resk-llm-0.1.0/resk_llm.egg-info/requires.txt

@@ -0,0 +1 @@
+openai

resk-llm-0.1.0/resk_llm.egg-info/top_level.txt

@@ -0,0 +1 @@
+resk-llm

resk-llm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

resk-llm-0.1.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("LICENCE.txt", "r", encoding="utf-8") as f:
+    license_text = f.read()
+
+setup(
+    name="resk-llm",
+    version="0.1.0",
+    author="Resk",
+    author_email="nielzac@proton.me",
+    description="Resk-LLM is a robust Python library designed to enhance security and manage context when interacting with OpenAI's language models. It provides a protective layer for API calls, safeguarding against common vulnerabilities and ensuring optimal performance.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Resk-Security/Resk-LLM",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+         "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    install_requires=[
+        "openai",
+    ],
+    license=license_text,
+)

resk-llm-0.1.0/tests/test_openai_protector.py.py

@@ -0,0 +1,65 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from resk.openai_protector import OpenAIProtector
+
+class TestOpenAIProtector(unittest.TestCase):
+
+    def setUp(self):
+        self.protector = OpenAIProtector(model="gpt-4o", preserved_prompts=2)
+
+    def test_sanitize_input(self):
+        input_text = "<script>alert('XSS')</script>Hello<endoftext>"
+        sanitized = self.protector.sanitize_input(input_text)
+        self.assertEqual(sanitized, "&lt;script&gt;alert('XSS')&lt;/script&gt;Hello")
+
+    def test_close_html_tags(self):
+        input_text = "<p>Unclosed paragraph<div>Nested <b>bold"
+        closed = self.protector._close_html_tags(input_text)
+        self.assertEqual(closed, "<p>Unclosed paragraph<div>Nested <b>bold</b></div></p>")
+
+    def test_truncate_text(self):
+        long_text = "a" * (self.protector.max_context_length * 5)
+        truncated = self.protector._truncate_text(long_text)
+        self.assertEqual(len(truncated), self.protector.max_context_length * 4)
+
+    def test_manage_sliding_context(self):
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there!"},
+            {"role": "user", "content": "How are you?"},
+            {"role": "assistant", "content": "I'm doing well, thank you for asking!"},
+        ]
+        managed = self.protector.manage_sliding_context(messages)
+        self.assertEqual(len(managed), 4)  # 2 preserved + 2 most recent
+        self.assertEqual(managed[0], messages[0])
+        self.assertEqual(managed[1], messages[1])
+        self.assertEqual(managed[-2], messages[-2])
+        self.assertEqual(managed[-1], messages[-1])
+
+    @patch('openai.ChatCompletion.create')
+    def test_protect_openai_call(self, mock_create):
+        mock_response = MagicMock()
+        mock_response.choices = [MagicMock(message={"content": "Test response"})]
+        mock_create.return_value = mock_response
+
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Hello<endoftext>"},
+        ]
+
+        response = self.protector.protect_openai_call(
+            mock_create,
+            model="gpt-4o",
+            messages=messages
+        )
+
+        self.assertEqual(response.choices[0].message["content"], "Test response")
+        mock_create.assert_called_once()
+        called_args = mock_create.call_args[1]
+        self.assertEqual(called_args['model'], "gpt-4o")
+        self.assertEqual(len(called_args['messages']), 2)
+        self.assertNotIn("<endoftext>", called_args['messages'][1]['content'])
+
+if __name__ == '__main__':
+    unittest.main()