webscout 8.3.4__py3-none-any.whl → 8.3.6__py3-none-any.whl

webscout/auth/routes.py

@@ -41,6 +41,7 @@ from .request_processing import (
     handle_streaming_response, handle_non_streaming_response
 )
 from .auth_system import get_auth_components
+from .simple_logger import request_logger
 from webscout.DWEBS import GoogleSearch
 from webscout.yep_search import YepSearch
 from webscout.webscout_search import WEBS
@@ -165,6 +166,7 @@ class Api:
         self._register_chat_routes()
         self._register_auth_routes()
         self._register_websearch_routes()
+        self._register_monitoring_routes()
 
     def _register_model_routes(self):
         """Register model listing routes."""        
@@ -241,6 +243,7 @@ class Api:
             }
         )
         async def chat_completions(
+            request: Request,
             chat_request: ChatCompletionRequest = Body(...)
         ):
             """Handle chat completion requests with comprehensive error handling."""
@@ -271,11 +274,39 @@ class Api:
                 # Prepare parameters for provider
                 params = prepare_provider_params(chat_request, model_name, processed_messages)
 
+                # Extract client IP address
+                client_ip = request.client.host if request.client else "unknown"
+                if "x-forwarded-for" in request.headers:
+                    client_ip = request.headers["x-forwarded-for"].split(",")[0].strip()
+                elif "x-real-ip" in request.headers:
+                    client_ip = request.headers["x-real-ip"]
+
+                # Extract question from messages (last user message)
+                question = ""
+                for msg in reversed(processed_messages):
+                    if msg.get("role") == "user":
+                        content = msg.get("content", "")
+                        if isinstance(content, str):
+                            question = content
+                        elif isinstance(content, list) and content:
+                            # Handle content with multiple parts (text, images, etc.)
+                            for part in content:
+                                if isinstance(part, dict) and part.get("type") == "text":
+                                    question = part.get("text", "")
+                                    break
+                        break
+
                 # Handle streaming vs non-streaming
                 if chat_request.stream:
-                    return await handle_streaming_response(provider, params, request_id)
+                    return await handle_streaming_response(
+                        provider, params, request_id, client_ip, question, model_name, start_time,
+                        provider_class.__name__, request
+                    )
                 else:
-                    return await handle_non_streaming_response(provider, params, request_id, start_time)
+                    return await handle_non_streaming_response(
+                        provider, params, request_id, start_time, client_ip, question, model_name,
+                        provider_class.__name__, request
+                    )
 
             except APIError:
                 # Re-raise API errors as-is
@@ -565,3 +596,69 @@ class Api:
                     "error": f"Search request failed: {msg}",
                     "footer": github_footer
                 }
+
+    def _register_monitoring_routes(self):
+        """Register monitoring and analytics routes for no-auth mode."""
+
+        @self.app.get(
+            "/monitor/requests",
+            tags=["Monitoring"],
+            description="Get recent API requests (no-auth mode only)"
+        )
+        async def get_recent_requests(limit: int = Query(10, description="Number of recent requests to fetch")):
+            """Get recent API requests for monitoring."""
+            if AppConfig.auth_required:
+                return {"error": "Monitoring is only available in no-auth mode"}
+            
+            try:
+                return await request_logger.get_recent_requests(limit)
+            except Exception as e:
+                return {"error": f"Failed to fetch requests: {str(e)}"}
+
+        @self.app.get(
+            "/monitor/stats",
+            tags=["Monitoring"], 
+            description="Get API usage statistics (no-auth mode only)"
+        )
+        async def get_api_stats():
+            """Get API usage statistics."""
+            if AppConfig.auth_required:
+                return {"error": "Monitoring is only available in no-auth mode"}
+            
+            try:
+                return await request_logger.get_stats()
+            except Exception as e:
+                return {"error": f"Failed to fetch stats: {str(e)}"}
+
+        @self.app.get(
+            "/monitor/health",
+            tags=["Monitoring"],
+            description="Health check with database status"
+        )
+        async def enhanced_health_check():
+            """Enhanced health check including database connectivity."""
+            try:
+                # Check database connectivity
+                db_status = "disconnected"
+                if request_logger.supabase_client:
+                    try:
+                        # Try a simple query to check connectivity
+                        result = request_logger.supabase_client.table("api_requests").select("id").limit(1).execute()
+                        db_status = "connected"
+                    except Exception as e:
+                        db_status = f"error: {str(e)[:100]}"
+                
+                return {
+                    "status": "healthy",
+                    "database": db_status,
+                    "auth_required": AppConfig.auth_required,
+                    "rate_limit_enabled": AppConfig.rate_limit_enabled,
+                    "request_logging_enabled": AppConfig.request_logging_enabled,
+                    "timestamp": datetime.now(timezone.utc).isoformat()
+                }
+            except Exception as e:
+                return {
+                    "status": "unhealthy",
+                    "error": str(e),
+                    "timestamp": datetime.now(timezone.utc).isoformat()
+                }

webscout/auth/server.py

@@ -40,8 +40,15 @@ logger = Logger(
     fmt=LogFormat.DEFAULT
 )
 
-# Global configuration instance
-config = ServerConfig()
+# Global configuration instance - lazy initialization
+config = None
+
+def get_config() -> ServerConfig:
+    """Get or create the global configuration instance."""
+    global config
+    if config is None:
+        config = ServerConfig()
+    return config
 
 
 def create_app():

webscout/auth/simple_logger.py

@@ -0,0 +1,236 @@
+"""
+Simple database logging for no-auth mode.
+Logs API requests directly to Supabase without authentication.
+"""
+
+import os
+import uuid
+import asyncio
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any
+import json
+
+from webscout.Litlogger import Logger, LogLevel, LogFormat, ConsoleHandler
+import sys
+
+# Setup logger
+logger = Logger(
+    name="webscout.api.simple_db",
+    level=LogLevel.INFO,
+    handlers=[ConsoleHandler(stream=sys.stdout)],
+    fmt=LogFormat.DEFAULT
+)
+
+try:
+    from supabase import create_client, Client
+    SUPABASE_AVAILABLE = True
+except ImportError:
+    logger.warning("Supabase not available. Install with: pip install supabase")
+    SUPABASE_AVAILABLE = False
+
+
+class SimpleRequestLogger:
+    """Simple request logger for no-auth mode."""
+    
+    def __init__(self):
+        self.supabase_client: Optional[Client] = None
+        self.initialize_supabase()
+    
+    def initialize_supabase(self):
+        """Initialize Supabase client if credentials are available."""
+        if not SUPABASE_AVAILABLE:
+            logger.warning("Supabase package not installed. Request logging disabled.")
+            return
+            
+        supabase_url = os.getenv("SUPABASE_URL")
+        supabase_key = os.getenv("SUPABASE_ANON_KEY")
+        
+        if supabase_url and supabase_key:
+            try:
+                self.supabase_client = create_client(supabase_url, supabase_key)
+                logger.info("Supabase client initialized for request logging")
+                
+            except Exception as e:
+                logger.error(f"Failed to initialize Supabase client: {e}")
+                self.supabase_client = None
+        else:
+            logger.info("Supabase credentials not found. Request logging disabled.")
+    
+    async def log_request(
+        self,
+        request_id: str,
+        ip_address: str,
+        model: str,
+        question: str,
+        answer: str,
+        provider: Optional[str] = None,
+        request_time: Optional[datetime] = None,
+        response_time: Optional[datetime] = None,
+        processing_time_ms: Optional[float] = None,
+        tokens_used: Optional[int] = None,
+        error: Optional[str] = None,
+        user_agent: Optional[str] = None
+    ) -> bool:
+        """
+        Log API request details to Supabase.
+        
+        Args:
+            request_id: Unique identifier for the request
+            ip_address: Client IP address
+            model: Model used for the request
+            question: User's question/prompt
+            answer: AI's response
+            provider: Provider used (e.g., ChatGPT, Claude, etc.)
+            request_time: When the request was received
+            response_time: When the response was sent
+            processing_time_ms: Processing time in milliseconds
+            tokens_used: Number of tokens consumed
+            error: Error message if any
+            user_agent: User agent string
+            
+        Returns:
+            bool: True if logged successfully, False otherwise
+        """
+        if not self.supabase_client:
+            # Still log to console for debugging
+            logger.info(f"Request {request_id}: {model} - {question[:100]}...")
+            return False
+        
+        if not request_time:
+            request_time = datetime.now(timezone.utc)
+        
+        if not response_time:
+            response_time = datetime.now(timezone.utc)
+        
+        try:
+            data = {
+                "request_id": request_id,
+                "ip_address": ip_address,
+                "model": model,
+                "provider": provider or "unknown",
+                "question": question[:2000] if question else "",  # Truncate long questions
+                "answer": answer[:5000] if answer else "",  # Truncate long answers
+                "request_time": request_time.isoformat(),
+                "response_time": response_time.isoformat(),
+                "processing_time_ms": processing_time_ms,
+                "tokens_used": tokens_used,
+                "error": error[:1000] if error else None,  # Truncate long errors
+                "user_agent": user_agent[:500] if user_agent else None,
+                "created_at": datetime.now(timezone.utc).isoformat()
+            }
+            
+            result = self.supabase_client.table("api_requests").insert(data).execute()
+            
+            if result.data:
+                logger.info(f"✅ Request {request_id} logged to database")
+                return True
+            else:
+                logger.error(f"❌ Failed to log request {request_id}: No data returned")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to log request {request_id}: {e}")
+            return False
+    
+    async def get_recent_requests(self, limit: int = 10) -> Dict[str, Any]:
+        """Get recent API requests for monitoring."""
+        if not self.supabase_client:
+            return {"error": "Database not available", "requests": []}
+        
+        try:
+            result = self.supabase_client.table("api_requests")\
+                .select("request_id, ip_address, model, provider, created_at, processing_time_ms, error")\
+                .order("created_at", desc=True)\
+                .limit(limit)\
+                .execute()
+            
+            return {
+                "requests": result.data if result.data else [],
+                "count": len(result.data) if result.data else 0
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to get recent requests: {e}")
+            return {"error": str(e), "requests": []}
+    
+    async def get_stats(self) -> Dict[str, Any]:
+        """Get basic statistics about API usage."""
+        if not self.supabase_client:
+            return {"error": "Database not available"}
+        
+        try:
+            # Get total requests today
+            today = datetime.now(timezone.utc).date().isoformat()
+            
+            today_requests = self.supabase_client.table("api_requests")\
+                .select("request_id", count="exact")\
+                .gte("created_at", f"{today}T00:00:00Z")\
+                .execute()
+            
+            # Get requests by model (last 100)
+            model_requests = self.supabase_client.table("api_requests")\
+                .select("model")\
+                .order("created_at", desc=True)\
+                .limit(100)\
+                .execute()
+            
+            model_counts = {}
+            if model_requests.data:
+                for req in model_requests.data:
+                    model = req.get("model", "unknown")
+                    model_counts[model] = model_counts.get(model, 0) + 1
+            
+            return {
+                "today_requests": today_requests.count if hasattr(today_requests, 'count') else 0,
+                "model_usage": model_counts,
+                "available": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to get stats: {e}")
+            return {"error": str(e), "available": False}
+
+
+# Global instance
+request_logger = SimpleRequestLogger()
+
+
+async def log_api_request(
+    request_id: str,
+    ip_address: str,
+    model: str,
+    question: str,
+    answer: str,
+    **kwargs
+) -> bool:
+    """Convenience function to log API requests."""
+    return await request_logger.log_request(
+        request_id=request_id,
+        ip_address=ip_address,
+        model=model,
+        question=question,
+        answer=answer,
+        **kwargs
+    )
+
+
+def get_client_ip(request) -> str:
+    """Extract client IP address from request."""
+    # Check for X-Forwarded-For header (common with proxies/load balancers)
+    forwarded_for = request.headers.get("X-Forwarded-For")
+    if forwarded_for:
+        # Take the first IP in the chain
+        return forwarded_for.split(",")[0].strip()
+    
+    # Check for X-Real-IP header
+    real_ip = request.headers.get("X-Real-IP")
+    if real_ip:
+        return real_ip.strip()
+    
+    # Fall back to direct client IP
+    return getattr(request.client, "host", "unknown")
+
+
+def generate_request_id() -> str:
+    """Generate a unique request ID."""
+    return str(uuid.uuid4())

webscout/conversation.py

@@ -165,29 +165,19 @@ class Conversation:
             ))
 
     def _compress_history(self) -> None:
-        """Compress history when it exceeds threshold."""
+        """Delete old history when it exceeds threshold."""
         if len(self.messages) > self.compression_threshold:
-            # Keep recent messages and summarize older ones
-            keep_recent = 100  # Adjust based on needs
-            self.messages = (
-                [self._summarize_messages(self.messages[:-keep_recent])] +
-                self.messages[-keep_recent:]
-            )
-
-    def _summarize_messages(self, messages: List[Message]) -> Message:
-        """Create a summary message from older messages."""
-        return Message(
-            role="system",
-            content="[History Summary] Previous conversation summarized for context",
-            metadata={"summarized_count": len(messages)}
-        )
+            # Remove oldest messages, keep only the most recent ones
+            self.messages = self.messages[-self.compression_threshold:]
+
+    # _summarize_messages removed
 
     def gen_complete_prompt(self, prompt: str, intro: Optional[str] = None) -> str:
         """Generate complete prompt with enhanced context management."""
         if not self.status:
             return prompt
 
-        intro = intro or self.intro
+        intro = intro or self.intro or ""
         
         # Add tool information if available
         tools_description = self.get_tools_description()
@@ -260,6 +250,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
 
     def _trim_chat_history(self, chat_history: str, intro: str) -> str:
         """Trim chat history with improved token management."""
+        intro = intro or ""
         total_length = len(intro) + len(chat_history)
         
         if total_length > self.history_offset:
@@ -273,20 +264,31 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         return chat_history
 
     def add_message(self, role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None:
-        """Add a message with enhanced validation and metadata support."""
+        """Add a message with enhanced validation and metadata support. Deletes oldest messages if total word count exceeds max_tokens_to_sample."""
         try:
             role = role.lower()  # Normalize role to lowercase
             if not self.validate_message(role, content):
                 raise MessageValidationError("Invalid message role or content")
 
+            # Calculate total word count in history
+            def total_word_count(messages):
+                return sum(len(msg.content.split()) for msg in messages)
+
+            # Remove oldest messages until total word count is below limit
+            temp_messages = self.messages.copy()
+            while temp_messages and (total_word_count(temp_messages) + len(content.split()) > self.max_tokens_to_sample):
+                temp_messages.pop(0)
+
+            self.messages = temp_messages
+
             message = Message(role=role, content=content, metadata=metadata or {})
             self.messages.append(message)
-            
+
             if self.file and self.update_file:
                 self._append_to_file(message)
-            
+
             self._compress_history()
-            
+
         except Exception as e:
             raise ConversationError(f"Failed to add message: {str(e)}") from e