Upload 27 files

app.py

@@ -104,15 +104,55 @@ def chat_completions():
         # Pass special token flag to proxy manager for unlimited processing
         response = proxy_manager.forward_request(data, token_data['api_key'], is_special_token)
         
-        # Check if request was rejected due to token limits (only for regular tokens)
-        if not is_special_token and response.status_code == 400:
+        # Handle all error responses with detailed error information
+        if response.status_code != 200:
             try:
+                # Try to get detailed error information from the response
                 error_data = response.json()
-                if error_data.get('error', {}).get('type') == 'token_limit_exceeded':
-                    return jsonify(error_data), 400
-            except:
-                pass
-        
+                
+                # Enhance error with provider and context information
+                enhanced_error = {
+                    "error": {
+                        "message": error_data.get('error', {}).get('message', f"HTTP {response.status_code} error from {proxy_manager.current_provider}"),
+                        "type": error_data.get('error', {}).get('type', 'api_error'),
+                        "code": response.status_code,
+                        "provider": proxy_manager.current_provider,
+                        "model": model
+                    }
+                }
+                
+                # Include original error details if available
+                if 'error' in error_data and isinstance(error_data['error'], dict):
+                    original_error = error_data['error']
+                    if 'details' in original_error:
+                        enhanced_error['error']['details'] = original_error['details']
+                    if 'param' in original_error:
+                        enhanced_error['error']['param'] = original_error['param']
+                    if 'code' in original_error:
+                        enhanced_error['error']['original_code'] = original_error['code']
+                
+                return jsonify(enhanced_error), response.status_code
+                
+            except (ValueError, KeyError) as e:
+                # If response is not valid JSON or missing expected fields
+                try:
+                    response_text = response.text
+                except:
+                    response_text = "Unable to read response content"
+                
+                enhanced_error = {
+                    "error": {
+                        "message": f"HTTP {response.status_code} error from {proxy_manager.current_provider}: {response_text[:200]}",
+                        "type": "api_error",
+                        "code": response.status_code,
+                        "provider": proxy_manager.current_provider,
+                        "model": model,
+                        "details": f"Response parsing error: {str(e)}"
+                    }
+                }
+                return jsonify(enhanced_error), response.status_code
+        
+        # Handle successful responses
         if response.status_code == 200:
             # Update token usage only for regular tokens and if not from cache
             if not is_special_token:
@@ -120,11 +160,15 @@ def chat_completions():
                 if cache_status != 'HIT':
                     storage.update_token_usage(token_data['id'], model_cost, model)
         
-        # Return response
+        # Return successful response
         if data.get('stream', False):
             return response.iter_content(chunk_size=1024), response.status_code, dict(response.headers)
         else:
-            return response.json(), response.status_code
+            try:
+                return response.json(), response.status_code
+            except ValueError:
+                # If successful response is not JSON, return as text
+                return {"message": response.text, "status": "success"}, response.status_code
             
     except Exception as e:
         return jsonify({"error": {"message": str(e), "type": "internal_error"}}), 500

utils/proxy.py

@@ -94,7 +94,8 @@ class OpenRouterProxy:
             return self._create_error_response(
                 500,
                 "connection_error",
-                f"Failed to connect to OpenRouter: {str(e)}"
+                f"Failed to connect to OpenRouter: {str(e)}",
+                {"provider": "openrouter", "model": model}
             )
     
     def _prepare_optimized_headers(self, api_key: str, cache_key: str) -> Dict[str, str]:
@@ -116,17 +117,24 @@ class OpenRouterProxy:
         headers.update(cache_headers)
         return headers
     
-    def _create_error_response(self, status_code: int, error_type: str, message: str) -> requests.Response:
-        """Crea una respuesta de error mock"""
+    def _create_error_response(self, status_code: int, error_type: str, message: str, context: Dict = None) -> requests.Response:
+        """Crea una respuesta de error mock con contexto adicional"""
         mock_response = requests.Response()
         mock_response.status_code = status_code
-        mock_response._content = json.dumps({
+        
+        error_data = {
             "error": {
                 "message": message,
                 "type": error_type,
                 "code": status_code
             }
-        }).encode('utf-8')
+        }
+        
+        # Add context information if provided
+        if context:
+            error_data["error"].update(context)
+        
+        mock_response._content = json.dumps(error_data).encode('utf-8')
         mock_response.headers['Content-Type'] = 'application/json'
         return mock_response
     

utils/requesty_proxy.py

@@ -364,8 +364,21 @@ class RequestyProxy:
                     try:
                         error_data = response.json()
                         last_error = error_data.get('error', {}).get('message', f'HTTP {response.status_code}')
+                        # Store detailed error for final response
+                        error_details = {
+                            "status_code": response.status_code,
+                            "response_body": error_data,
+                            "headers": dict(response.headers),
+                            "url": url
+                        }
                     except:
                         last_error = f'HTTP {response.status_code} - API key authentication failed'
+                        error_details = {
+                            "status_code": response.status_code,
+                            "response_body": response.text,
+                            "headers": dict(response.headers),
+                            "url": url
+                        }
                     
                     logger.warning(f"Requesty API key failed with {response.status_code}, trying next key...")
                     continue
@@ -378,15 +391,53 @@ class RequestyProxy:
                     try:
                         error_data = response.json()
                         last_error = error_data.get('error', {}).get('message', f'HTTP {response.status_code}')
+                        # Store detailed error for final response
+                        error_details = {
+                            "status_code": response.status_code,
+                            "response_body": error_data,
+                            "headers": dict(response.headers),
+                            "url": url
+                        }
                     except:
                         last_error = f'HTTP {response.status_code} - Server error'
+                        error_details = {
+                            "status_code": response.status_code,
+                            "response_body": response.text,
+                            "headers": dict(response.headers),
+                            "url": url
+                        }
                     
                     logger.warning(f"Requesty server error {response.status_code}, trying next key...")
                     continue
                 
                 else:
-                    # Other HTTP errors (4xx client errors) - don't retry, return immediately
+                    # Other HTTP errors (4xx client errors) - don't retry, return with detailed error
                     logger.warning(f"Requesty client error {response.status_code}, not retrying")
+                    
+                    try:
+                        error_data = response.json()
+                        # Enhance the response with additional context
+                        if 'error' in error_data:
+                            error_data['error']['provider'] = 'requesty'
+                            error_data['error']['url'] = url
+                            error_data['error']['headers'] = dict(response.headers)
+                        
+                        # Update response content with enhanced error data
+                        response._content = json.dumps(error_data).encode('utf-8')
+                    except:
+                        # If we can't parse JSON, create our own error response
+                        return self._create_error_response(
+                            response.status_code,
+                            "client_error",
+                            f"HTTP {response.status_code}: {response.text}",
+                            {
+                                "original_status_code": response.status_code,
+                                "response_body": response.text,
+                                "headers": dict(response.headers),
+                                "url": url
+                            }
+                        )
+                    
                     return response
                 
             except requests.exceptions.RequestException as e:
@@ -400,10 +451,20 @@ class RequestyProxy:
         
         # If we get here, all keys failed
         logger.error(f"All Requesty API keys failed after {attempts} attempts")
+        
+        # Include detailed error information if available
+        error_context = {
+            "attempts_made": attempts,
+            "max_attempts": max_attempts,
+            "active_keys_count": len(self.key_rotator.active_keys),
+            "last_error_details": locals().get('error_details', None)
+        }
+        
         return self._create_error_response(
             500,
             "all_keys_failed",
-            f"All API keys are currently unavailable. Last error: {last_error}"
+            f"All API keys are currently unavailable. Last error: {last_error}",
+            error_context
         )
     
     def _add_requesty_optimizations(self, data: Dict[Any, Any], bypass_limitations: bool = False) -> Dict[Any, Any]:
@@ -440,17 +501,25 @@ class RequestyProxy:
         
         return headers
     
-    def _create_error_response(self, status_code: int, error_type: str, message: str) -> requests.Response:
-        """Create a mock error response"""
+    def _create_error_response(self, status_code: int, error_type: str, message: str, context: Dict = None) -> requests.Response:
+        """Create a mock error response with additional context"""
         mock_response = requests.Response()
         mock_response.status_code = status_code
-        mock_response._content = json.dumps({
+        
+        error_data = {
             "error": {
                 "message": message,
                 "type": error_type,
-                "code": status_code
+                "code": status_code,
+                "provider": "requesty"
             }
-        }).encode('utf-8')
+        }
+        
+        # Add context information if provided
+        if context:
+            error_data["error"].update(context)
+        
+        mock_response._content = json.dumps(error_data).encode('utf-8')
         mock_response.headers['Content-Type'] = 'application/json'
         return mock_response