aisbf 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

{aisbf-0.2.3.data → aisbf-0.2.4.data}/data/share/aisbf/aisbf/handlers.py

@@ -164,71 +164,195 @@ class RotationHandler:
             logger.error(f"Rotation {rotation_id} not found")
             raise HTTPException(status_code=400, detail=f"Rotation {rotation_id} not found")
 
-        logger.info(f"Rotation config: {rotation_config}")
+        logger.info(f"Rotation config loaded successfully")
         providers = rotation_config.providers
         logger.info(f"Number of providers in rotation: {len(providers)}")
         
-        weighted_models = []
+        # Collect all available models with their weights
+        available_models = []
+        skipped_providers = []
+        total_models_considered = 0
 
+        logger.info(f"=== MODEL SELECTION PROCESS START ===")
+        logger.info(f"Scanning providers for available models...")
+        
         for provider in providers:
-            logger.info(f"Processing provider: {provider['provider_id']}")
+            provider_id = provider['provider_id']
+            logger.info(f"")
+            logger.info(f"--- Processing provider: {provider_id} ---")
+            
+            # Check if provider exists in configuration
+            provider_config = self.config.get_provider(provider_id)
+            if not provider_config:
+                logger.error(f"  [ERROR] Provider {provider_id} not found in providers configuration")
+                logger.error(f"  Available providers: {list(self.config.providers.keys())}")
+                logger.error(f"  Skipping this provider")
+                skipped_providers.append(provider_id)
+                continue
+            
+            # Check if provider is rate limited/deactivated
+            provider_handler = get_provider_handler(provider_id, provider.get('api_key'))
+            if provider_handler.is_rate_limited():
+                logger.warning(f"  [SKIPPED] Provider {provider_id} is rate limited/deactivated")
+                logger.warning(f"  Reason: Provider has exceeded failure threshold or is in cooldown period")
+                skipped_providers.append(provider_id)
+                continue
+            
+            logger.info(f"  [AVAILABLE] Provider {provider_id} is active and ready")
+            
+            models_in_provider = len(provider['models'])
+            total_models_considered += models_in_provider
+            logger.info(f"  Found {models_in_provider} model(s) in this provider")
+            
             for model in provider['models']:
-                logger.info(f"  Model: {model['name']}, weight: {model['weight']}")
-                weighted_models.extend([model] * model['weight'])
-
-        logger.info(f"Total weighted models: {len(weighted_models)}")
-        if not weighted_models:
-            logger.error("No models available in rotation")
-            raise HTTPException(status_code=400, detail="No models available in rotation")
+                model_name = model['name']
+                model_weight = model['weight']
+                model_rate_limit = model.get('rate_limit', 'N/A')
+                
+                logger.info(f"    - Model: {model_name}")
+                logger.info(f"      Weight (Priority): {model_weight}")
+                logger.info(f"      Rate Limit: {model_rate_limit}")
+                
+                # Add provider_id and api_key to model for later use
+                model_with_provider = model.copy()
+                model_with_provider['provider_id'] = provider_id
+                model_with_provider['api_key'] = provider.get('api_key')
+                available_models.append(model_with_provider)
+
+        logger.info(f"")
+        logger.info(f"=== MODEL SELECTION SUMMARY ===")
+        logger.info(f"Total providers scanned: {len(providers)}")
+        logger.info(f"Providers skipped (rate limited): {len(skipped_providers)}")
+        if skipped_providers:
+            logger.info(f"Skipped providers: {', '.join(skipped_providers)}")
+        logger.info(f"Total models considered: {total_models_considered}")
+        logger.info(f"Total models available: {len(available_models)}")
+        
+        if not available_models:
+            logger.error("No models available in rotation (all providers may be rate limited)")
+            logger.error("All providers in this rotation are currently deactivated")
+            raise HTTPException(status_code=503, detail="No models available in rotation (all providers may be rate limited)")
 
+        # Sort models by weight in descending order (higher weight = higher priority)
+        available_models.sort(key=lambda m: m['weight'], reverse=True)
+        
+        logger.info(f"")
+        logger.info(f"=== PRIORITY-BASED SELECTION ===")
+        logger.info(f"Models sorted by weight (descending priority):")
+        for idx, model in enumerate(available_models, 1):
+            logger.info(f"  {idx}. {model['name']} (provider: {model['provider_id']}, weight: {model['weight']})")
+
+        # Find the highest weight
+        highest_weight = available_models[0]['weight']
+        logger.info(f"")
+        logger.info(f"Highest priority weight: {highest_weight}")
+
+        # Filter models with the highest weight
+        highest_weight_models = [m for m in available_models if m['weight'] == highest_weight]
+        logger.info(f"Models with highest priority ({highest_weight}): {len(highest_weight_models)}")
+        for model in highest_weight_models:
+            logger.info(f"  - {model['name']} (provider: {model['provider_id']})")
+
+        # If multiple models have the same highest weight, randomly select among them
         import random
-        selected_model = random.choice(weighted_models)
-        logger.info(f"Selected model: {selected_model}")
-
-        provider_id = selected_model['provider_id']
-        api_key = selected_model.get('api_key')
-        model_name = selected_model['name']
+        if len(highest_weight_models) > 1:
+            logger.info(f"Multiple models with same highest priority - performing random selection")
+            selected_model = random.choice(highest_weight_models)
+            logger.info(f"Randomly selected from {len(highest_weight_models)} candidates")
+        else:
+            selected_model = highest_weight_models[0]
+            logger.info(f"Single model with highest priority - deterministic selection")
         
-        logger.info(f"Selected provider_id: {provider_id}")
-        logger.info(f"Selected model_name: {model_name}")
-        logger.info(f"API key present: {bool(api_key)}")
-
-        logger.info(f"Getting provider handler for {provider_id}")
-        handler = get_provider_handler(provider_id, api_key)
-        logger.info(f"Provider handler obtained: {handler.__class__.__name__}")
-
-        if handler.is_rate_limited():
-            raise HTTPException(status_code=503, detail="All providers temporarily unavailable")
-
-        try:
-            logger.info(f"Model requested: {model_name}")
-            logger.info(f"Messages count: {len(request_data.get('messages', []))}")
-            logger.info(f"Max tokens: {request_data.get('max_tokens')}")
-            logger.info(f"Temperature: {request_data.get('temperature', 1.0)}")
-            logger.info(f"Stream: {request_data.get('stream', False)}")
+        logger.info(f"")
+        logger.info(f"=== FINAL SELECTION ===")
+        logger.info(f"Selected model: {selected_model['name']}")
+        logger.info(f"Selected provider: {selected_model['provider_id']}")
+        logger.info(f"Model weight (priority): {selected_model['weight']}")
+        logger.info(f"Model rate limit: {selected_model.get('rate_limit', 'N/A')}")
+        logger.info(f"=== MODEL SELECTION PROCESS END ===")
+
+        # Retry logic: Try up to 2 times with different models
+        max_retries = 2
+        tried_models = []
+        last_error = None
+        
+        for attempt in range(max_retries):
+            logger.info(f"")
+            logger.info(f"=== ATTEMPT {attempt + 1}/{max_retries} ===")
             
-            # Apply rate limiting with model-specific rate limit if available
-            rate_limit = selected_model.get('rate_limit')
-            logger.info(f"Model-specific rate limit: {rate_limit}")
-            logger.info("Applying rate limiting...")
-            await handler.apply_rate_limit(rate_limit)
-            logger.info("Rate limiting applied")
+            # Select a model that hasn't been tried yet
+            remaining_models = [m for m in available_models if m not in tried_models]
+            
+            if not remaining_models:
+                logger.error(f"No more models available to try")
+                logger.error(f"All {len(available_models)} models have been attempted")
+                break
+            
+            # Sort remaining models by weight and select the best one
+            remaining_models.sort(key=lambda m: m['weight'], reverse=True)
+            current_model = remaining_models[0]
+            tried_models.append(current_model)
+            
+            logger.info(f"Trying model: {current_model['name']} (provider: {current_model['provider_id']})")
+            logger.info(f"Attempt {attempt + 1} of {max_retries}")
+            
+            provider_id = current_model['provider_id']
+            api_key = current_model.get('api_key')
+            model_name = current_model['name']
+            
+            logger.info(f"Getting provider handler for {provider_id}")
+            handler = get_provider_handler(provider_id, api_key)
+            logger.info(f"Provider handler obtained: {handler.__class__.__name__}")
 
-            logger.info(f"Sending request to provider handler...")
-            response = await handler.handle_request(
-                model=model_name,
-                messages=request_data['messages'],
-                max_tokens=request_data.get('max_tokens'),
-                temperature=request_data.get('temperature', 1.0),
-                stream=request_data.get('stream', False)
-            )
-            logger.info(f"Response received from provider")
-            handler.record_success()
-            logger.info(f"=== RotationHandler.handle_rotation_request END ===")
-            return response
-        except Exception as e:
-            handler.record_failure()
-            raise HTTPException(status_code=500, detail=str(e))
+            if handler.is_rate_limited():
+                logger.warning(f"Provider {provider_id} is rate limited, skipping to next model")
+                continue
+            
+            try:
+                logger.info(f"Model requested: {model_name}")
+                logger.info(f"Messages count: {len(request_data.get('messages', []))}")
+                logger.info(f"Max tokens: {request_data.get('max_tokens')}")
+                logger.info(f"Temperature: {request_data.get('temperature', 1.0)}")
+                logger.info(f"Stream: {request_data.get('stream', False)}")
+                
+                # Apply rate limiting with model-specific rate limit if available
+                rate_limit = current_model.get('rate_limit')
+                logger.info(f"Model-specific rate limit: {rate_limit}")
+                logger.info("Applying rate limiting...")
+                await handler.apply_rate_limit(rate_limit)
+                logger.info("Rate limiting applied")
+
+                logger.info(f"Sending request to provider handler...")
+                response = await handler.handle_request(
+                    model=model_name,
+                    messages=request_data['messages'],
+                    max_tokens=request_data.get('max_tokens'),
+                    temperature=request_data.get('temperature', 1.0),
+                    stream=request_data.get('stream', False)
+                )
+                logger.info(f"Response received from provider")
+                handler.record_success()
+                logger.info(f"=== RotationHandler.handle_rotation_request END ===")
+                logger.info(f"Request succeeded on attempt {attempt + 1}")
+                return response
+            except Exception as e:
+                last_error = str(e)
+                handler.record_failure()
+                logger.error(f"Attempt {attempt + 1} failed: {str(e)}")
+                logger.error(f"Error type: {type(e).__name__}")
+                logger.error(f"Will try next model...")
+                continue
+        
+        # All retries exhausted
+        logger.error(f"")
+        logger.error(f"=== ALL RETRIES EXHAUSTED ===")
+        logger.error(f"Attempted {len(tried_models)} different model(s): {[m['name'] for m in tried_models]}")
+        logger.error(f"Last error: {last_error}")
+        logger.error(f"Max retries ({max_retries}) reached without success")
+        raise HTTPException(
+            status_code=503,
+            detail=f"All providers in rotation failed after {max_retries} attempts. Last error: {last_error}"
+        )
 
     async def handle_rotation_model_list(self, rotation_id: str) -> List[Dict]:
         rotation_config = self.config.get_rotation(rotation_id)
@@ -310,6 +434,11 @@ class AutoselectHandler:
 
     async def _get_model_selection(self, prompt: str) -> str:
         """Send the autoselect prompt to a model and get the selection"""
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== AUTOSELECT MODEL SELECTION START ===")
+        logger.info(f"Using 'general' rotation for model selection")
+        
         # Use the first available provider/model for the selection
         # This is a simple implementation - could be enhanced to use a specific selection model
         rotation_handler = RotationHandler()
@@ -322,27 +451,64 @@ class AutoselectHandler:
             "stream": False
         }
         
+        logger.info(f"Selection request parameters:")
+        logger.info(f"  Temperature: 0.1 (low for deterministic selection)")
+        logger.info(f"  Max tokens: 100 (short response expected)")
+        logger.info(f"  Stream: False")
+        
         # Use the fallback rotation for the selection
         try:
+            logger.info(f"Sending selection request to rotation handler...")
             response = await rotation_handler.handle_rotation_request("general", selection_request)
+            logger.info(f"Selection response received")
+            
             content = response.get('choices', [{}])[0].get('message', {}).get('content', '')
+            logger.info(f"Raw response content: {content[:200]}..." if len(content) > 200 else f"Raw response content: {content}")
+            
             model_id = self._extract_model_selection(content)
+            
+            if model_id:
+                logger.info(f"=== AUTOSELECT MODEL SELECTION SUCCESS ===")
+                logger.info(f"Selected model ID: {model_id}")
+            else:
+                logger.warning(f"=== AUTOSELECT MODEL SELECTION FAILED ===")
+                logger.warning(f"Could not extract model ID from response")
+                logger.warning(f"Response content: {content}")
+            
             return model_id
         except Exception as e:
+            logger.error(f"=== AUTOSELECT MODEL SELECTION ERROR ===")
+            logger.error(f"Error during model selection: {str(e)}")
+            logger.error(f"Will use fallback model")
             # If selection fails, we'll handle it in the main handler
             return None
 
     async def handle_autoselect_request(self, autoselect_id: str, request_data: Dict) -> Dict:
         """Handle an autoselect request"""
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== AUTOSELECT REQUEST START ===")
+        logger.info(f"Autoselect ID: {autoselect_id}")
+        
         autoselect_config = self.config.get_autoselect(autoselect_id)
         if not autoselect_config:
+            logger.error(f"Autoselect {autoselect_id} not found")
             raise HTTPException(status_code=400, detail=f"Autoselect {autoselect_id} not found")
 
+        logger.info(f"Autoselect config loaded")
+        logger.info(f"Available models for selection: {len(autoselect_config.available_models)}")
+        for model_info in autoselect_config.available_models:
+            logger.info(f"  - {model_info.model_id}: {model_info.description}")
+        logger.info(f"Fallback model: {autoselect_config.fallback}")
+
         # Extract the user prompt from the request
         user_messages = request_data.get('messages', [])
         if not user_messages:
+            logger.error("No messages provided")
             raise HTTPException(status_code=400, detail="No messages provided")
         
+        logger.info(f"User messages count: {len(user_messages)}")
+        
         # Build a string representation of the user prompt
         user_prompt = ""
         for msg in user_messages:
@@ -353,37 +519,73 @@ class AutoselectHandler:
                 content = str(content)
             user_prompt += f"{role}: {content}\n"
 
+        logger.info(f"User prompt length: {len(user_prompt)} characters")
+        logger.info(f"User prompt preview: {user_prompt[:200]}..." if len(user_prompt) > 200 else f"User prompt: {user_prompt}")
+
         # Build the autoselect prompt
+        logger.info(f"Building autoselect prompt...")
         autoselect_prompt = self._build_autoselect_prompt(user_prompt, autoselect_config)
+        logger.info(f"Autoselect prompt built (length: {len(autoselect_prompt)} characters)")
 
         # Get the model selection
+        logger.info(f"Requesting model selection from AI...")
         selected_model_id = await self._get_model_selection(autoselect_prompt)
 
         # Validate the selected model
+        logger.info(f"=== MODEL VALIDATION ===")
         if not selected_model_id:
             # Fallback to the configured fallback model
+            logger.warning(f"No model ID returned from selection")
+            logger.warning(f"Using fallback model: {autoselect_config.fallback}")
             selected_model_id = autoselect_config.fallback
         else:
             # Check if the selected model is in the available models list
             available_ids = [m.model_id for m in autoselect_config.available_models]
             if selected_model_id not in available_ids:
+                logger.warning(f"Selected model '{selected_model_id}' not in available models list")
+                logger.warning(f"Available models: {available_ids}")
+                logger.warning(f"Using fallback model: {autoselect_config.fallback}")
                 selected_model_id = autoselect_config.fallback
+            else:
+                logger.info(f"Selected model '{selected_model_id}' is valid and available")
+
+        logger.info(f"=== FINAL MODEL CHOICE ===")
+        logger.info(f"Selected model ID: {selected_model_id}")
+        logger.info(f"Selection method: {'AI-selected' if selected_model_id != autoselect_config.fallback else 'Fallback'}")
 
         # Now proxy the actual request to the selected rotation
+        logger.info(f"Proxying request to rotation: {selected_model_id}")
         rotation_handler = RotationHandler()
-        return await rotation_handler.handle_rotation_request(selected_model_id, request_data)
+        response = await rotation_handler.handle_rotation_request(selected_model_id, request_data)
+        logger.info(f"=== AUTOSELECT REQUEST END ===")
+        return response
 
     async def handle_autoselect_streaming_request(self, autoselect_id: str, request_data: Dict):
         """Handle an autoselect streaming request"""
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== AUTOSELECT STREAMING REQUEST START ===")
+        logger.info(f"Autoselect ID: {autoselect_id}")
+        
         autoselect_config = self.config.get_autoselect(autoselect_id)
         if not autoselect_config:
+            logger.error(f"Autoselect {autoselect_id} not found")
             raise HTTPException(status_code=400, detail=f"Autoselect {autoselect_id} not found")
 
+        logger.info(f"Autoselect config loaded")
+        logger.info(f"Available models for selection: {len(autoselect_config.available_models)}")
+        for model_info in autoselect_config.available_models:
+            logger.info(f"  - {model_info.model_id}: {model_info.description}")
+        logger.info(f"Fallback model: {autoselect_config.fallback}")
+
         # Extract the user prompt from the request
         user_messages = request_data.get('messages', [])
         if not user_messages:
+            logger.error("No messages provided")
             raise HTTPException(status_code=400, detail="No messages provided")
         
+        logger.info(f"User messages count: {len(user_messages)}")
+        
         # Build a string representation of the user prompt
         user_prompt = ""
         for msg in user_messages:
@@ -393,21 +595,41 @@ class AutoselectHandler:
                 content = str(content)
             user_prompt += f"{role}: {content}\n"
 
+        logger.info(f"User prompt length: {len(user_prompt)} characters")
+        logger.info(f"User prompt preview: {user_prompt[:200]}..." if len(user_prompt) > 200 else f"User prompt: {user_prompt}")
+
         # Build the autoselect prompt
+        logger.info(f"Building autoselect prompt...")
         autoselect_prompt = self._build_autoselect_prompt(user_prompt, autoselect_config)
+        logger.info(f"Autoselect prompt built (length: {len(autoselect_prompt)} characters)")
 
         # Get the model selection
+        logger.info(f"Requesting model selection from AI...")
         selected_model_id = await self._get_model_selection(autoselect_prompt)
 
         # Validate the selected model
+        logger.info(f"=== MODEL VALIDATION ===")
         if not selected_model_id:
+            logger.warning(f"No model ID returned from selection")
+            logger.warning(f"Using fallback model: {autoselect_config.fallback}")
             selected_model_id = autoselect_config.fallback
         else:
             available_ids = [m.model_id for m in autoselect_config.available_models]
             if selected_model_id not in available_ids:
+                logger.warning(f"Selected model '{selected_model_id}' not in available models list")
+                logger.warning(f"Available models: {available_ids}")
+                logger.warning(f"Using fallback model: {autoselect_config.fallback}")
                 selected_model_id = autoselect_config.fallback
+            else:
+                logger.info(f"Selected model '{selected_model_id}' is valid and available")
+
+        logger.info(f"=== FINAL MODEL CHOICE ===")
+        logger.info(f"Selected model ID: {selected_model_id}")
+        logger.info(f"Selection method: {'AI-selected' if selected_model_id != autoselect_config.fallback else 'Fallback'}")
+        logger.info(f"Request mode: Streaming")
 
         # Now proxy the actual streaming request to the selected rotation
+        logger.info(f"Proxying streaming request to rotation: {selected_model_id}")
         rotation_handler = RotationHandler()
         
         async def stream_generator():
@@ -419,8 +641,10 @@ class AutoselectHandler:
                 for chunk in response:
                     yield f"data: {chunk}\n\n".encode('utf-8')
             except Exception as e:
+                logger.error(f"Error in streaming response: {str(e)}")
                 yield f"data: {str(e)}\n\n".encode('utf-8')
 
+        logger.info(f"=== AUTOSELECT STREAMING REQUEST END ===")
         return StreamingResponse(stream_generator(), media_type="text/event-stream")
 
     async def handle_autoselect_model_list(self, autoselect_id: str) -> List[Dict]:

{aisbf-0.2.3.data → aisbf-0.2.4.data}/data/share/aisbf/aisbf/providers.py

@@ -62,14 +62,56 @@ class BaseProviderHandler:
             self.last_request_time = time.time()
 
     def record_failure(self):
+        import logging
+        logger = logging.getLogger(__name__)
+        
         self.error_tracking['failures'] += 1
         self.error_tracking['last_failure'] = time.time()
+        
+        failure_count = self.error_tracking['failures']
+        logger.warning(f"=== PROVIDER FAILURE RECORDED ===")
+        logger.warning(f"Provider: {self.provider_id}")
+        logger.warning(f"Failure count: {failure_count}/3")
+        logger.warning(f"Last failure time: {self.error_tracking['last_failure']}")
+        
         if self.error_tracking['failures'] >= 3:
             self.error_tracking['disabled_until'] = time.time() + 300  # 5 minutes
+            disabled_until_time = self.error_tracking['disabled_until']
+            cooldown_remaining = int(disabled_until_time - time.time())
+            logger.error(f"!!! PROVIDER DISABLED !!!")
+            logger.error(f"Provider: {self.provider_id}")
+            logger.error(f"Reason: 3 consecutive failures reached")
+            logger.error(f"Disabled until: {disabled_until_time}")
+            logger.error(f"Cooldown period: {cooldown_remaining} seconds (5 minutes)")
+            logger.error(f"Provider will be automatically re-enabled after cooldown")
+        else:
+            remaining_failures = 3 - failure_count
+            logger.warning(f"Provider still active. {remaining_failures} more failure(s) will disable it")
+        logger.warning(f"=== END FAILURE RECORDING ===")
 
     def record_success(self):
+        import logging
+        logger = logging.getLogger(__name__)
+        
+        was_disabled = self.error_tracking['disabled_until'] is not None
+        previous_failures = self.error_tracking['failures']
+        
         self.error_tracking['failures'] = 0
         self.error_tracking['disabled_until'] = None
+        
+        logger.info(f"=== PROVIDER SUCCESS RECORDED ===")
+        logger.info(f"Provider: {self.provider_id}")
+        logger.info(f"Previous failure count: {previous_failures}")
+        logger.info(f"Failure count reset to: 0")
+        
+        if was_disabled:
+            logger.info(f"!!! PROVIDER RE-ENABLED !!!")
+            logger.info(f"Provider: {self.provider_id}")
+            logger.info(f"Reason: Successful request after cooldown period")
+            logger.info(f"Provider is now active and available for requests")
+        else:
+            logger.info(f"Provider remains active")
+        logger.info(f"=== END SUCCESS RECORDING ===")
 
 class GoogleProviderHandler(BaseProviderHandler):
     def __init__(self, provider_id: str, api_key: str):