webscout 8.3.3__py3-none-any.whl → 8.3.5__py3-none-any.whl

webscout/auth/routes.py

@@ -41,9 +41,11 @@ 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
+from webscout.Bing_search import BingSearch
 
 # Setup logger
 logger = Logger(
@@ -164,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."""        
@@ -240,6 +243,7 @@ class Api:
             }
         )
         async def chat_completions(
+            request: Request,
             chat_request: ChatCompletionRequest = Body(...)
         ):
             """Handle chat completion requests with comprehensive error handling."""
@@ -270,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
@@ -483,11 +515,11 @@ class Api:
         @self.app.get(
             "/search",
             tags=["Web search"],
-            description="Unified web search endpoint supporting Google, Yep, and DuckDuckGo with text, news, images, and suggestions search types."
+            description="Unified web search endpoint supporting Google, Yep, DuckDuckGo, and Bing with text, news, images, and suggestions search types."
         )
         async def websearch(
             q: str = Query(..., description="Search query"),
-            engine: str = Query("google", description="Search engine: google, yep, duckduckgo"),
+            engine: str = Query("google", description="Search engine: google, yep, duckduckgo, bing"),
             max_results: int = Query(10, description="Maximum number of results"),
             region: str = Query("all", description="Region code (optional)"),
             safesearch: str = Query("moderate", description="Safe search: on, moderate, off"),
@@ -532,8 +564,24 @@ class Api:
                         return {"engine": "duckduckgo", "type": "suggestions", "results": results}
                     else:
                         return {"error": "DuckDuckGo only supports text and suggestions in this API.", "footer": github_footer}
+                elif engine == "bing":
+                    bs = BingSearch()
+                    if type == "text":
+                        results = bs.text(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
+                        return {"engine": "bing", "type": "text", "results": [r.__dict__ for r in results]}
+                    elif type == "news":
+                        results = bs.news(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
+                        return {"engine": "bing", "type": "news", "results": [r.__dict__ for r in results]}
+                    elif type == "images":
+                        results = bs.images(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
+                        return {"engine": "bing", "type": "images", "results": [r.__dict__ for r in results]}
+                    elif type == "suggestions":
+                        results = bs.suggestions(q, region=region)
+                        return {"engine": "bing", "type": "suggestions", "results": results}
+                    else:
+                        return {"error": "Bing only supports text, news, images, and suggestions in this API.", "footer": github_footer}
                 else:
-                    return {"error": "Unknown engine. Use one of: google, yep, duckduckgo.", "footer": github_footer}
+                    return {"error": "Unknown engine. Use one of: google, yep, duckduckgo, bing.", "footer": github_footer}
             except Exception as e:
                 # Special handling for rate limit errors
                 msg = str(e)
@@ -548,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())