librechat-python-sdk 0.1.0__py3-none-any.whl

examples/basic_chat.py

@@ -0,0 +1,39 @@
+"""
+Basic Chat Example using LibreChat Python SDK
+"""
+
+import os
+from dotenv import load_dotenv
+from librechat_client import LibreChatClient
+
+def main():
+    load_dotenv()
+    
+    base_url = os.getenv("LIBRECHAT_BASE_URL", "https://chat.example.com")
+    refresh_token = os.getenv("LIBRECHAT_REFRESH_TOKEN")
+    connect_sid = os.getenv("LIBRECHAT_CONNECT_SID")
+    
+    if not refresh_token or refresh_token == "YOUR_REFRESH_TOKEN_HERE":
+        print("[!] Please configure LIBRECHAT_REFRESH_TOKEN in your .env file.")
+        return
+
+    # Initialize client
+    client = LibreChatClient(
+        base_url=base_url,
+        refresh_token=refresh_token,
+        connect_sid=connect_sid
+    )
+
+    print("[+] Sending request to LibreChat...")
+    
+    # Send a prompt to the agent endpoint
+    # The client automatically handles JWT refresh & token rotation
+    response = client.send_agent_message(
+        prompt="Explain the difference between GitOps and traditional CI/CD in 3 bullet points."
+    )
+    
+    print("\n=== LibreChat Response ===")
+    print(response.get("text", response))
+
+if __name__ == "__main__":
+    main()

examples/file_monitor/main.py

@@ -0,0 +1,99 @@
+"""
+Continuous Folder Monitor Daemon Example
+"""
+
+import os
+import sys
+import time
+import logging
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Ensure SDK root is in python path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+from librechat_client import LibreChatClient
+from tracker import FileStateTracker
+
+try:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler
+    HAS_WATCHDOG = True
+except ImportError:
+    HAS_WATCHDOG = False
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] (FileMonitor) %(message)s"
+)
+logger = logging.getLogger("FileMonitor")
+
+def run_monitor():
+    load_dotenv()
+    
+    watch_dir = Path(os.getenv("WATCH_DIR", "./watch_folder")).resolve()
+    output_dir = Path(os.getenv("OUTPUT_DIR", "./output_folder")).resolve()
+    
+    watch_dir.mkdir(parents=True, exist_ok=True)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    base_url = os.getenv("LIBRECHAT_BASE_URL", "https://chat.example.com")
+    refresh_token = os.getenv("LIBRECHAT_REFRESH_TOKEN")
+    connect_sid = os.getenv("LIBRECHAT_CONNECT_SID")
+    
+    if not refresh_token or refresh_token == "YOUR_REFRESH_TOKEN_HERE":
+        logger.error("LIBRECHAT_REFRESH_TOKEN is not set in .env!")
+        return
+
+    client = LibreChatClient(
+        base_url=base_url,
+        refresh_token=refresh_token,
+        connect_sid=connect_sid
+    )
+    tracker = FileStateTracker()
+    
+    logger.info(f"Monitoring folder: {watch_dir}")
+    
+    def process_file(filepath: Path):
+        if not filepath.is_file() or filepath.name.startswith(".") or tracker.is_processed(filepath):
+            return
+        logger.info(f"Processing new file: {filepath.name}")
+        try:
+            content = filepath.read_text(encoding="utf-8")
+            response = client.send_agent_message(prompt=f"Summarize:\n\n{content}")
+            
+            output_file = output_dir / f"{filepath.stem}_summary_{int(time.time())}.md"
+            output_file.write_text(str(response.get("text", response)), encoding="utf-8")
+            
+            tracker.mark_processed(filepath, output_file)
+            logger.info(f"[✓] Saved response to: {output_file}")
+        except Exception as e:
+            logger.error(f"Failed to process '{filepath.name}': {e}")
+
+    # Initial scan for offline changes across reboots
+    for p in watch_dir.rglob("*"):
+        process_file(p)
+
+    if HAS_WATCHDOG:
+        class Handler(FileSystemEventHandler):
+            def on_created(self, event):
+                process_file(Path(event.src_path))
+            def on_modified(self, event):
+                process_file(Path(event.src_path))
+
+        observer = Observer()
+        observer.schedule(Handler(), str(watch_dir), recursive=True)
+        observer.start()
+
+    try:
+        while True:
+            time.sleep(30)
+            for p in watch_dir.rglob("*"):
+                process_file(p)
+    except KeyboardInterrupt:
+        logger.info("Monitor stopped.")
+        if HAS_WATCHDOG:
+            observer.stop()
+
+if __name__ == "__main__":
+    run_monitor()

examples/file_monitor/tracker.py

@@ -0,0 +1,69 @@
+"""
+File state tracking module for long-running file monitoring.
+"""
+
+import os
+import json
+import time
+import hashlib
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger("LibreChatSDK.FileTracker")
+
+class FileStateTracker:
+    """Tracks file modification timestamps and SHA256 hashes across reboots."""
+    def __init__(self, db_path: str = "processed_files.json"):
+        self.db_path = db_path
+        self.data: Dict[str, Dict[str, Any]] = {}
+        self.load()
+
+    def load(self):
+        if os.path.exists(self.db_path):
+            try:
+                with open(self.db_path, "r", encoding="utf-8") as f:
+                    self.data = json.load(f)
+            except Exception as e:
+                logger.warning(f"Could not load state DB '{self.db_path}': {e}")
+                self.data = {}
+
+    def save(self):
+        try:
+            with open(self.db_path, "w", encoding="utf-8") as f:
+                json.dump(self.data, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save state DB '{self.db_path}': {e}")
+
+    @staticmethod
+    def compute_sha256(filepath: Path) -> str:
+        hasher = hashlib.sha256()
+        try:
+            with open(filepath, "rb") as f:
+                while chunk := f.read(65536):
+                    hasher.update(chunk)
+            return hasher.hexdigest()
+        except Exception:
+            return ""
+
+    def is_processed(self, filepath: Path) -> bool:
+        key = str(filepath.resolve())
+        if key not in self.data:
+            return False
+        
+        entry = self.data[key]
+        if entry.get("mtime") == filepath.stat().st_mtime:
+            return True
+            
+        current_hash = self.compute_sha256(filepath)
+        return entry.get("hash") == current_hash and bool(current_hash)
+
+    def mark_processed(self, filepath: Path, output_path: Optional[Path] = None):
+        key = str(filepath.resolve())
+        self.data[key] = {
+            "mtime": filepath.stat().st_mtime,
+            "hash": self.compute_sha256(filepath),
+            "processed_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "output_file": str(output_path) if output_path else None
+        }
+        self.save()

examples/gitops_iac_auditor/main.py

@@ -0,0 +1,116 @@
+"""
+GitOps Infrastructure-as-Code (IaC) Automated Security Auditor
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+A DevOps automation daemon that monitors a repository directory for Kubernetes manifests, 
+Terraform files, or Dockerfiles, passes changes to LibreChat for AI-assisted security 
+and compliance auditing, and generates markdown audit reports.
+"""
+
+import os
+import sys
+import time
+import logging
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Ensure parent directory is in python path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+from librechat_client import LibreChatClient
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] (GitOps-Auditor) %(message)s"
+)
+logger = logging.getLogger("GitOpsAuditor")
+
+DEFAULT_IAC_EXTENSIONS = {".yaml", ".yml", ".tf", ".dockerfile", "dockerfile"}
+
+GITOPS_SECURITY_PROMPT = """
+You are an expert DevOps & DevSecOps engineer performing an automated security code review.
+Analyze the following Infrastructure-as-Code (IaC) configuration for security risks, compliance violations, and best practices.
+
+Focus on:
+1. Least Privilege & Access Control (e.g., non-root containers, open security groups 0.0.0.0/0).
+2. Resource Management (missing CPU/memory limits, quotas).
+3. Secret Exposure (hardcoded credentials, API keys, unencrypted storage).
+4. Container Security (floating image tags, privilege escalation).
+
+Return your findings formatted as a clear Markdown report with risk ratings (HIGH, MEDIUM, LOW) and actionable fix recommendations.
+
+File Content:
+```
+{content}
+```
+"""
+
+def run_iac_auditor():
+    load_dotenv()
+    
+    watch_dir = Path(os.getenv("IAC_WATCH_DIR", "./iac_repository")).resolve()
+    reports_dir = Path(os.getenv("REPORTS_DIR", "./reports")).resolve()
+    
+    watch_dir.mkdir(parents=True, exist_ok=True)
+    reports_dir.mkdir(parents=True, exist_ok=True)
+    
+    base_url = os.getenv("LIBRECHAT_BASE_URL", "https://chat.example.com")
+    refresh_token = os.getenv("LIBRECHAT_REFRESH_TOKEN")
+    connect_sid = os.getenv("LIBRECHAT_CONNECT_SID")
+    
+    if not refresh_token or refresh_token == "YOUR_REFRESH_TOKEN_HERE":
+        logger.error("LIBRECHAT_REFRESH_TOKEN is not configured in .env!")
+        return
+
+    client = LibreChatClient(
+        base_url=base_url,
+        refresh_token=refresh_token,
+        connect_sid=connect_sid
+    )
+    
+    logger.info(f"GitOps Security Auditor running. Monitoring IaC folder: {watch_dir}")
+    
+    processed_files = set()
+    
+    while True:
+        for file_path in watch_dir.rglob("*"):
+            if not file_path.is_file() or file_path.name.startswith("."):
+                continue
+                
+            is_iac_file = file_path.suffix.lower() in DEFAULT_IAC_EXTENSIONS or "dockerfile" in file_path.name.lower()
+            if not is_iac_file:
+                continue
+                
+            file_key = f"{file_path.resolve()}:{file_path.stat().st_mtime}"
+            if file_key in processed_files:
+                continue
+                
+            logger.info(f"--> Auditing IaC configuration file: {file_path.name}")
+            try:
+                content = file_path.read_text(encoding="utf-8")
+                prompt = GITOPS_SECURITY_PROMPT.format(content=content)
+                
+                logger.info(f"Submitting '{file_path.name}' to LibreChat LLM endpoint...")
+                result = client.send_agent_message(prompt=prompt)
+                
+                report_text = result.get("text") if isinstance(result, dict) else str(result)
+                
+                report_path = reports_dir / f"audit_{file_path.stem}_{int(time.time())}.md"
+                report_content = (
+                    f"# GitOps Security Audit Report\n"
+                    f"- **Target File**: `{file_path.name}`\n"
+                    f"- **Audited At**: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+                    f"--- \n\n"
+                    f"{report_text}\n"
+                )
+                report_path.write_text(report_content, encoding="utf-8")
+                
+                logger.info(f"[✓] Audit Report generated: {report_path}")
+                processed_files.add(file_key)
+                
+            except Exception as err:
+                logger.error(f"[x] Failed to audit file '{file_path.name}': {err}")
+                
+        time.sleep(15)
+
+if __name__ == "__main__":
+    run_iac_auditor()

librechat_client/__init__.py

@@ -0,0 +1,20 @@
+"""
+LibreChat Python SDK
+~~~~~~~~~~~~~~~~~~~
+A resilient Python client SDK for interacting with LibreChat backend APIs with 
+Refresh Token Rotation (RTR) and long-running process state persistence.
+"""
+
+from .client import LibreChatClient
+from .exceptions import LibreChatError, LibreChatAuthError, LibreChatAPIError, TokenExpiredError
+from .utils import parse_jwt_payload, is_jwt_expired
+
+__all__ = [
+    "LibreChatClient",
+    "LibreChatError",
+    "LibreChatAuthError",
+    "LibreChatAPIError",
+    "TokenExpiredError",
+    "parse_jwt_payload",
+    "is_jwt_expired",
+]

librechat_client/client.py

@@ -0,0 +1,203 @@
+"""
+Core LibreChat API Client with Refresh Token Rotation (RTR) and Session Persistence.
+"""
+
+import os
+import json
+import time
+import logging
+from typing import Any, Dict, Optional, Union
+import requests
+
+from .utils import is_jwt_expired
+from .exceptions import LibreChatAuthError, LibreChatAPIError
+
+logger = logging.getLogger("LibreChatSDK.Client")
+
+DEFAULT_STATE_FILE = "session_tokens.json"
+
+class LibreChatClient:
+    """
+    An enterprise-grade, resilient Python client for LibreChat web applications.
+    
+    Features:
+    - Automatic Refresh Token Rotation (RTR)
+    - Proactive JWT access token expiration monitoring
+    - Multi-day session persistence across laptop sleep & system reboots
+    - Exponential backoff retry logic for network drops
+    """
+    def __init__(
+        self,
+        base_url: str,
+        refresh_token: str,
+        connect_sid: Optional[str] = None,
+        token_provider: str = "librechat",
+        state_file: str = DEFAULT_STATE_FILE,
+        verify_ssl: bool = True
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.verify_ssl = verify_ssl
+        self.state_file = state_file
+        self.access_token: Optional[str] = None
+        self.refresh_token = refresh_token
+        self.connect_sid = connect_sid
+        self.token_provider = token_provider
+        
+        self.session = requests.Session()
+        
+        # Load rotated tokens from disk if state file exists
+        self._load_state()
+        
+        # Standard browser headers to ensure CORS & reverse proxy compatibility
+        self.session.headers.update({
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36",
+            "Origin": self.base_url,
+            "Referer": f"{self.base_url}/",
+            "Accept": "application/json, text/plain, */*"
+        })
+        
+        self._sync_cookies()
+
+    def _sync_cookies(self):
+        """Bind authentication cookies to the session."""
+        self.session.cookies.set("refreshToken", self.refresh_token)
+        self.session.cookies.set("token_provider", self.token_provider)
+        if self.connect_sid:
+            self.session.cookies.set("connect.sid", self.connect_sid)
+
+    def _load_state(self):
+        """Restore active rotated refresh token from persistent storage."""
+        if os.path.exists(self.state_file):
+            try:
+                with open(self.state_file, "r", encoding="utf-8") as f:
+                    state = json.load(f)
+                    if state.get("refresh_token"):
+                        self.refresh_token = state["refresh_token"]
+                        logger.info("Restored latest rotated refresh token from state file.")
+                    if state.get("access_token"):
+                        self.access_token = state["access_token"]
+                    if state.get("connect_sid"):
+                        self.connect_sid = state["connect_sid"]
+            except Exception as e:
+                logger.warning(f"Could not read state file '{self.state_file}': {e}")
+
+    def _save_state(self):
+        """Save updated tokens after a successful Refresh Token Rotation."""
+        state = {
+            "refresh_token": self.refresh_token,
+            "access_token": self.access_token,
+            "connect_sid": self.connect_sid,
+            "updated_at": time.strftime("%Y-%m-%d %H:%M:%S")
+        }
+        try:
+            with open(self.state_file, "w", encoding="utf-8") as f:
+                json.dump(state, f, indent=2)
+            logger.debug(f"Saved token state to {self.state_file}")
+        except Exception as e:
+            logger.error(f"Failed to write state file '{self.state_file}': {e}")
+
+    def refresh_access_token(self, max_retries: int = 5) -> bool:
+        """
+        Request a fresh JWT access token via POST /api/auth/refresh.
+        Handles Refresh Token Rotation (RTR) seamlessly.
+        """
+        refresh_url = f"{self.base_url}/api/auth/refresh"
+        self._sync_cookies()
+        
+        backoff = 2
+        for attempt in range(1, max_retries + 1):
+            logger.info(f"Refresing JWT access token (Attempt {attempt}/{max_retries})...")
+            try:
+                response = self.session.post(
+                    refresh_url,
+                    json={},
+                    verify=self.verify_ssl,
+                    timeout=15
+                )
+                
+                # Fallback to GET if method is restricted by custom proxy
+                if response.status_code in (404, 405):
+                    response = self.session.get(refresh_url, verify=self.verify_ssl, timeout=15)
+                    
+                if response.status_code == 200:
+                    data = response.json()
+                    new_token = data.get("token") or data.get("accessToken")
+                    if new_token:
+                        self.access_token = new_token
+                        logger.info("Successfully acquired new access token.")
+                        
+                        # Handle Refresh Token Rotation
+                        if "refreshToken" in response.cookies:
+                            rotated_token = response.cookies["refreshToken"]
+                            if rotated_token != self.refresh_token:
+                                logger.info("Detected new rotated refreshToken from server.")
+                                self.refresh_token = rotated_token
+                        
+                        self._save_state()
+                        return True
+                    else:
+                        logger.error(f"Token refresh payload missing token field: {data}")
+                else:
+                    logger.error(f"Refresh failed with HTTP {response.status_code}: {response.text}")
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Network error during token refresh: {e}. Retrying in {backoff}s...")
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 60)
+
+        return False
+
+    def request(self, method: str, endpoint: str, max_retries: int = 3, **kwargs) -> requests.Response:
+        """
+        Execute an HTTP request against LibreChat with automatic proactive token check & 401 recovery.
+        """
+        url = f"{self.base_url}{endpoint}" if endpoint.startswith("/") else f"{self.base_url}/{endpoint}"
+        
+        # Proactively check token expiry
+        if not self.access_token or is_jwt_expired(self.access_token):
+            logger.info("Access token missing or near expiration. Executing refresh...")
+            if not self.refresh_access_token():
+                raise LibreChatAuthError("Failed to refresh access token using stored refresh token.")
+
+        headers = kwargs.pop("headers", {})
+        headers["Authorization"] = f"Bearer {self.access_token}"
+        
+        backoff = 2
+        for attempt in range(1, max_retries + 1):
+            try:
+                response = self.session.request(method, url, headers=headers, verify=self.verify_ssl, **kwargs)
+                
+                # Handle HTTP 401 Unauthorized by attempting token rotation retry
+                if response.status_code == 401:
+                    logger.warning("HTTP 401 Unauthorized encountered. Attempting emergency token refresh...")
+                    if self.refresh_access_token():
+                        headers["Authorization"] = f"Bearer {self.access_token}"
+                        response = self.session.request(method, url, headers=headers, verify=self.verify_ssl, **kwargs)
+                    else:
+                        raise LibreChatAuthError("HTTP 401 Unauthorized and token refresh failed.")
+
+                if response.status_code >= 400:
+                    raise LibreChatAPIError(
+                        f"LibreChat API returned HTTP {response.status_code}",
+                        status_code=response.status_code,
+                        response_text=response.text
+                    )
+                    
+                return response
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Network request attempt {attempt}/{max_retries} failed: {e}. Retrying in {backoff}s...")
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 30)
+
+        raise LibreChatAPIError(f"Network request to {url} failed after {max_retries} retries.", status_code=500)
+
+    def send_agent_message(self, prompt: str, agent_id: Optional[str] = None, conversation_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Send a prompt to the LibreChat Agent endpoint (/api/agents/chat/agents).
+        """
+        payload = {
+            "text": prompt,
+            "agent_id": agent_id,
+            "conversationId": conversation_id
+        }
+        response = self.request("POST", "/api/agents/chat/agents", json=payload)
+        return response.json()

librechat_client/exceptions.py

@@ -0,0 +1,22 @@
+"""
+Custom Exception Classes for LibreChat SDK
+"""
+
+class LibreChatError(Exception):
+    """Base exception for all LibreChat SDK errors."""
+    pass
+
+class LibreChatAuthError(LibreChatError):
+    """Raised when authentication or token refresh fails."""
+    pass
+
+class LibreChatAPIError(LibreChatError):
+    """Raised when API endpoints return error status codes."""
+    def __init__(self, message: str, status_code: int, response_text: str = ""):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_text = response_text
+
+class TokenExpiredError(LibreChatAuthError):
+    """Raised when a token has expired and cannot be auto-refreshed."""
+    pass

librechat_client/utils.py

@@ -0,0 +1,38 @@
+"""
+Utility functions for JWT parsing and token lifecycle management.
+"""
+
+import base64
+import json
+import time
+import logging
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger("LibreChatSDK.Utils")
+
+def parse_jwt_payload(token: str) -> Optional[Dict[str, Any]]:
+    """
+    Decodes an unencrypted JWT payload without requiring external crypto dependencies.
+    """
+    try:
+        parts = token.split(".")
+        if len(parts) != 3:
+            return None
+        payload_b64 = parts[1]
+        # Pad string if necessary
+        payload_b64 += "=" * (-len(payload_b64) % 4)
+        payload_bytes = base64.urlsafe_b64decode(payload_b64)
+        return json.loads(payload_bytes.decode("utf-8"))
+    except Exception as e:
+        logger.debug(f"Failed to parse JWT payload: {e}")
+        return None
+
+def is_jwt_expired(token: str, buffer_seconds: int = 60) -> bool:
+    """
+    Check if a JWT access token is expired or within buffer_seconds of expiration.
+    """
+    payload = parse_jwt_payload(token)
+    if not payload or "exp" not in payload:
+        return True
+    exp_timestamp = payload["exp"]
+    return (time.time() + buffer_seconds) >= exp_timestamp

librechat_python_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: librechat-python-sdk
+Version: 0.1.0
+Summary: A resilient, auto-refreshing Python client SDK for LibreChat API endpoints featuring Refresh Token Rotation (RTR) and multi-day state persistence.
+Author: Open Source Developer
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: devops
+Requires-Dist: watchdog>=3.0.0; extra == "devops"
+Dynamic: license-file
+
+# LibreChat Python SDK (`librechat-python-sdk`)
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+An enterprise-grade, resilient Python client SDK for interacting with **[LibreChat](https://github.com/danny-avila/LibreChat)** backend APIs. 
+
+Built specifically for **long-running daemons, multi-day background processes, and DevOps/GitOps automation pipelines**, this SDK handles LibreChat's **Refresh Token Rotation (RTR)**, short-lived JWT expirations, network disconnects during system sleep, and session state persistence across reboots.
+
+---
+
+## Key Features
+
+- 🔄 **Refresh Token Rotation (RTR) Support**: Automatically captures newly rotated refresh tokens returned in `Set-Cookie` headers and updates active sessions.
+- 💾 **Multi-Day State Persistence**: Saves updated session state to `session_tokens.json` on disk so long-running scripts survive laptop sleep/wake cycles and system reboots.
+- ⏱️ **Proactive Expiration Checks**: Decodes JWT access token expiration timestamps (`exp`) and preemptively refreshes tokens before sending API calls.
+- ⚡ **Network Fault Tolerance**: Built-in exponential backoff retries to handle intermittent Wi-Fi drops, sleep mode transitions, and network glitches.
+- 🛡️ **DevOps & GitOps Ready**: Out-of-the-box examples for automated IaC security auditing, continuous folder watching, and CI/CD log analysis.
+
+---
+
+## Architecture & Token Lifecycle
+
+LibreChat uses short-lived JWT access tokens (**15 minutes**) paired with long-lived refresh tokens (**7+ days**). Whenever a token refresh occurs, LibreChat revokes the old refresh token and issues a new one.
+
+```mermaid
+sequenceDiagram
+    participant PythonScript as Python Script / Daemon
+    participant SDK as LibreChatClient SDK
+    participant Disk as Local State File (session_tokens.json)
+    participant Server as LibreChat Backend
+
+    PythonScript->>SDK: send_agent_message(prompt)
+    SDK->>SDK: Check JWT Expiration (exp timestamp)
+    alt Access Token Expired or Missing
+        SDK->>Server: POST /api/auth/refresh (with refreshToken cookie)
+        Server-->>SDK: 200 OK + New Access Token + New Rotated RefreshToken
+        SDK->>Disk: Persist new tokens to session_tokens.json
+    end
+    SDK->>Server: POST /api/agents/chat/agents (Bearer Access Token)
+    Server-->>SDK: HTTP 200 OK (Agent Response Payload)
+    SDK-->>PythonScript: Return JSON Response
+```
+
+---
+
+## Installation
+
+Clone the repository and install in editable mode:
+
+```bash
+git clone https://github.com/your-username/librechat-python-sdk.git
+cd librechat-python-sdk
+pip install -e .
+```
+
+To include optional DevOps folder monitoring dependencies:
+
+```bash
+pip install -e .[devops]
+```
+
+---
+
+## Quickstart
+
+### 1. Environment Setup
+
+Create a `.env` file from the provided template:
+
+```bash
+cp .env.example .env
+```
+
+Fill in your LibreChat endpoint and browser session cookie:
+
+```env
+LIBRECHAT_BASE_URL=https://chat.example.com
+LIBRECHAT_REFRESH_TOKEN=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+LIBRECHAT_CONNECT_SID=s%3A...
+```
+
+### 2. Basic Usage
+
+```python
+import os
+from dotenv import load_dotenv
+from librechat_client import LibreChatClient
+
+load_dotenv()
+
+# Initialize resilient client
+client = LibreChatClient(
+    base_url=os.getenv("LIBRECHAT_BASE_URL"),
+    refresh_token=os.getenv("LIBRECHAT_REFRESH_TOKEN"),
+    connect_sid=os.getenv("LIBRECHAT_CONNECT_SID")
+)
+
+# Send a prompt to the agent endpoint
+response = client.send_agent_message(
+    prompt="Explain the benefits of Infrastructure-as-Code in DevSecOps."
+)
+
+print(response.get("text"))
+```
+
+---
+
+## DevOps & GitOps Showcase Examples
+
+The [`examples/`](examples/) directory includes real-world automation implementations:
+
+1. **[GitOps IaC Security Auditor](examples/gitops_iac_auditor/)**: Monitors a repository directory for Kubernetes YAMLs, Terraform files, and Dockerfiles, submitting changes to LibreChat for automated security compliance auditing.
+2. **[Multi-Day File Monitor Daemon](examples/file_monitor/)**: A background folder watcher service with state tracking (`processed_files.json`) that survives system reboots and long idle periods.
+3. **[Basic Chat Example](examples/basic_chat.py)**: Minimal 15-line quickstart script.
+
+---
+
+## Project Structure
+
+```
+librechat-python-sdk/
+├── .env.example              # Environment template
+├── .gitignore                # Production gitignore rules
+├── LICENSE                   # MIT License
+├── pyproject.toml            # Python packaging metadata
+├── README.md                 # Project documentation
+├── requirements.txt          # Package dependencies
+├── librechat_client/
+│   ├── __init__.py           # SDK package exports
+│   ├── client.py             # Core LibreChat API client with RTR & retry logic
+│   ├── exceptions.py         # Custom exception hierarchy
+│   └── utils.py              # JWT decoding & helper utilities
+└── examples/
+    ├── basic_chat.py         # Minimal usage script
+    ├── devops_iac_auditor/   # GitOps security auditor daemon example
+    └── file_monitor/         # Resilient folder monitor daemon example
+```
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

librechat_python_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+examples/basic_chat.py,sha256=I2IFznP7nHvNiOQAo1RehHiRPrI8k7Q8N2b_aaqUQbM,1130
+examples/file_monitor/main.py,sha256=dfBq0HMnEGDSsJt3hi8gr8AM-LL8TBEZ23HD3ZNKvlk,3149
+examples/file_monitor/tracker.py,sha256=ZSxx-BnCW4nkWLrSOs4G1-h5aOoXlSm6ikVNOPNe0tA,2267
+examples/gitops_iac_auditor/main.py,sha256=UmfwTbt6o30kgnQb9Hi4r_f-IF4IRivj4tlMZPs3jMk,4466
+librechat_client/__init__.py,sha256=hI82UsN6f0v7LW6R05Qgvx7yzcE6ZP-2OAmbKhCLz5g,572
+librechat_client/client.py,sha256=AWIN7E8Ud5UgZy2rI2zRyHc9okN-aD9Y343YwiSQVcM,8971
+librechat_client/exceptions.py,sha256=25IqxyOB_tjAKQSoVdRYlZdgoMbKa3mFiYBXKtz8f2Q,691
+librechat_client/utils.py,sha256=U2ggP19MEZTfVEf0gbaI6ZnlgD24z_Okyk0mfwYfrD0,1183
+librechat_python_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=M3cR1PlJHIOVkEtaebK5lK0EPJyFLrmstKLGJB-RTg0,1107
+librechat_python_sdk-0.1.0.dist-info/METADATA,sha256=oPiTZl9t-mSaafcbO8_-x5L2yJBPxn7hw3gqyl1ckbg,6162
+librechat_python_sdk-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+librechat_python_sdk-0.1.0.dist-info/top_level.txt,sha256=akSfwEbhgwTpJ9RLutUa6XcBSQHcgvmrseHM3N7cNak,26
+librechat_python_sdk-0.1.0.dist-info/RECORD,,

librechat_python_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

librechat_python_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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 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.

librechat_python_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+examples
+librechat_client