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

{aisbf-0.2.2.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):
@@ -249,30 +291,122 @@ class AnthropicProviderHandler(BaseProviderHandler):
         ]
 
 class OllamaProviderHandler(BaseProviderHandler):
-    def __init__(self, provider_id: str):
-        super().__init__(provider_id)
-        self.client = httpx.AsyncClient(base_url=config.providers[provider_id].endpoint)
+    def __init__(self, provider_id: str, api_key: Optional[str] = None):
+        super().__init__(provider_id, api_key)
+        # Increase timeout for Ollama requests (especially for cloud models)
+        # Using separate timeouts for connect, read, write, and pool
+        timeout = httpx.Timeout(
+            connect=60.0,      # 60 seconds to establish connection
+            read=300.0,         # 5 minutes to read response
+            write=60.0,         # 60 seconds to write request
+            pool=60.0           # 60 seconds for pool acquisition
+        )
+        self.client = httpx.AsyncClient(base_url=config.providers[provider_id].endpoint, timeout=timeout)
 
     async def handle_request(self, model: str, messages: List[Dict], max_tokens: Optional[int] = None,
                            temperature: Optional[float] = 1.0, stream: Optional[bool] = False) -> Dict:
+        import logging
+        import json
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== OllamaProviderHandler.handle_request START ===")
+        logger.info(f"Provider ID: {self.provider_id}")
+        logger.info(f"Endpoint: {self.client.base_url}")
+        logger.info(f"Model: {model}")
+        logger.info(f"Messages count: {len(messages)}")
+        logger.info(f"Max tokens: {max_tokens}")
+        logger.info(f"Temperature: {temperature}")
+        logger.info(f"Stream: {stream}")
+        logger.info(f"API key provided: {bool(self.api_key)}")
+        
         if self.is_rate_limited():
+            logger.error("Provider is rate limited")
             raise Exception("Provider rate limited")
 
         try:
+            # Test connection first
+            logger.info("Testing Ollama connection...")
+            try:
+                health_response = await self.client.get("/api/tags", timeout=10.0)
+                logger.info(f"Ollama health check passed: {health_response.status_code}")
+                logger.info(f"Available models: {health_response.json().get('models', [])}")
+            except Exception as e:
+                logger.error(f"Ollama health check failed: {str(e)}")
+                logger.error(f"Cannot connect to Ollama at {self.client.base_url}")
+                logger.error(f"Please ensure Ollama is running and accessible")
+                raise Exception(f"Cannot connect to Ollama at {self.client.base_url}: {str(e)}")
+            
             # Apply rate limiting
+            logger.info("Applying rate limiting...")
             await self.apply_rate_limit()
+            logger.info("Rate limiting applied")
 
-            response = await self.client.post("/api/generate", json={
+            prompt = "\n\n".join([f"{msg['role']}: {msg['content']}" for msg in messages])
+            logger.info(f"Prompt length: {len(prompt)} characters")
+            
+            request_data = {
                 "model": model,
-                "prompt": "\n\n".join([f"{msg['role']}: {msg['content']}" for msg in messages]),
+                "prompt": prompt,
                 "options": {
                     "temperature": temperature,
                     "num_predict": max_tokens
-                }
-            })
+                },
+                "stream": False  # Explicitly disable streaming for non-streaming requests
+            }
+            
+            # Add API key to headers if provided (for Ollama cloud models)
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+                logger.info("API key added to request headers for Ollama cloud")
+            
+            logger.info(f"Sending POST request to {self.client.base_url}/api/generate")
+            logger.info(f"Request data: {request_data}")
+            logger.info(f"Request headers: {headers}")
+            logger.info(f"Client timeout: {self.client.timeout}")
+            
+            response = await self.client.post("/api/generate", json=request_data, headers=headers)
+            logger.info(f"Response status code: {response.status_code}")
+            logger.info(f"Response content type: {response.headers.get('content-type')}")
+            logger.info(f"Response content length: {len(response.content)} bytes")
+            logger.info(f"Raw response content (first 500 chars): {response.text[:500]}")
             response.raise_for_status()
+            
+            # Ollama may return multiple JSON objects, parse them all
+            content = response.text
+            logger.info(f"Attempting to parse response as JSON...")
+            
+            try:
+                # Try parsing as single JSON first
+                response_json = response.json()
+                logger.info(f"Response parsed as single JSON: {response_json}")
+            except json.JSONDecodeError as e:
+                # If that fails, try parsing multiple JSON objects
+                logger.warning(f"Failed to parse as single JSON: {e}")
+                logger.info(f"Attempting to parse as multiple JSON objects...")
+                
+                # Parse multiple JSON objects (one per line)
+                responses = []
+                for line in content.strip().split('\n'):
+                    if line.strip():
+                        try:
+                            obj = json.loads(line)
+                            responses.append(obj)
+                        except json.JSONDecodeError as line_error:
+                            logger.error(f"Failed to parse line: {line}")
+                            logger.error(f"Error: {line_error}")
+                
+                if not responses:
+                    raise Exception("No valid JSON objects found in response")
+                
+                # Combine responses - take the last complete response
+                # Ollama sends multiple chunks, we want the final one
+                response_json = responses[-1]
+                logger.info(f"Parsed {len(responses)} JSON objects, using last one: {response_json}")
+            
+            logger.info(f"Final response: {response_json}")
             self.record_success()
-            return response.json()
+            logger.info(f"=== OllamaProviderHandler.handle_request END ===")
+            return response_json
         except Exception as e:
             self.record_failure()
             raise e
@@ -294,8 +428,29 @@ PROVIDER_HANDLERS = {
 }
 
 def get_provider_handler(provider_id: str, api_key: Optional[str] = None) -> BaseProviderHandler:
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.info(f"=== get_provider_handler START ===")
+    logger.info(f"Provider ID: {provider_id}")
+    logger.info(f"API key provided: {bool(api_key)}")
+    
     provider_config = config.get_provider(provider_id)
+    logger.info(f"Provider config: {provider_config}")
+    logger.info(f"Provider type: {provider_config.type}")
+    logger.info(f"Provider endpoint: {provider_config.endpoint}")
+    
     handler_class = PROVIDER_HANDLERS.get(provider_config.type)
+    logger.info(f"Handler class: {handler_class.__name__ if handler_class else 'None'}")
+    logger.info(f"Available handler types: {list(PROVIDER_HANDLERS.keys())}")
+    
     if not handler_class:
+        logger.error(f"Unsupported provider type: {provider_config.type}")
         raise ValueError(f"Unsupported provider type: {provider_config.type}")
-    return handler_class(provider_id, api_key)
+    
+    # All handlers now accept api_key as optional parameter
+    logger.info(f"Creating handler with provider_id and optional api_key")
+    handler = handler_class(provider_id, api_key)
+    
+    logger.info(f"Handler created: {handler.__class__.__name__}")
+    logger.info(f"=== get_provider_handler END ===")
+    return handler

aisbf-0.2.4.data/data/share/aisbf/main.py

@@ -0,0 +1,421 @@
+"""
+Copyleft (C) 2026 Stefy Lanza <stefy@nexlab.net>
+
+AISBF - AI Service Broker Framework || AI Should Be Free
+
+Main application for AISBF.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Why did the programmer quit his job? Because he didn't get arrays!
+
+Main application for AISBF.
+"""
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from aisbf.models import ChatCompletionRequest, ChatCompletionResponse
+from aisbf.handlers import RequestHandler, RotationHandler, AutoselectHandler
+from aisbf.config import config
+import time
+import logging
+import sys
+import os
+from logging.handlers import RotatingFileHandler
+from datetime import datetime, timedelta
+from collections import defaultdict
+from pathlib import Path
+
+def setup_logging():
+    """Setup logging with rotating file handlers"""
+    # Determine log directory based on user
+    if os.geteuid() == 0:
+        # Running as root - use /var/log/aisbf
+        log_dir = Path('/var/log/aisbf')
+    else:
+        # Running as user - use ~/.local/var/log/aisbf
+        log_dir = Path.home() / '.local' / 'var' / 'log' / 'aisbf'
+    
+    # Create log directory if it doesn't exist
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Setup rotating file handler for general logs
+    log_file = log_dir / 'aisbf.log'
+    file_handler = RotatingFileHandler(
+        log_file,
+        maxBytes=50*1024*1024,  # 50 MB
+        backupCount=5,
+        encoding='utf-8'
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    file_handler.setFormatter(file_formatter)
+    
+    # Setup rotating file handler for error logs
+    error_log_file = log_dir / 'aisbf_error.log'
+    error_handler = RotatingFileHandler(
+        error_log_file,
+        maxBytes=50*1024*1024,  # 50 MB
+        backupCount=5,
+        encoding='utf-8'
+    )
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(file_formatter)
+    
+    # Setup console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_formatter = logging.Formatter(
+        '%(asctime)s - %(levelname)s - %(message)s'
+    )
+    console_handler.setFormatter(console_formatter)
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG)
+    root_logger.addHandler(file_handler)
+    root_logger.addHandler(error_handler)
+    root_logger.addHandler(console_handler)
+    
+    # Redirect stderr to error log
+    sys.stderr = open(log_dir / 'aisbf_stderr.log', 'a')
+    
+    return logging.getLogger(__name__)
+
+# Configure logging
+logger = setup_logging()
+
+# Initialize handlers
+request_handler = RequestHandler()
+rotation_handler = RotationHandler()
+autoselect_handler = AutoselectHandler()
+
+app = FastAPI(title="AI Proxy Server")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {
+        "message": "AI Proxy Server is running",
+        "providers": list(config.providers.keys()),
+        "rotations": list(config.rotations.keys()),
+        "autoselect": list(config.autoselect.keys())
+    }
+
+@app.get("/api/rotations")
+async def list_rotations():
+    """List all available rotations"""
+    logger.info("=== LIST ROTATIONS REQUEST ===")
+    rotations_info = {}
+    for rotation_id, rotation_config in config.rotations.items():
+        models = []
+        for provider in rotation_config.providers:
+            for model in provider['models']:
+                models.append({
+                    "name": model['name'],
+                    "provider_id": provider['provider_id'],
+                    "weight": model['weight'],
+                    "rate_limit": model.get('rate_limit')
+                })
+        rotations_info[rotation_id] = {
+            "model_name": rotation_config.model_name,
+            "models": models
+        }
+    logger.info(f"Available rotations: {list(rotations_info.keys())}")
+    return rotations_info
+
+@app.post("/api/rotations/chat/completions")
+async def rotation_chat_completions(request: Request, body: ChatCompletionRequest):
+    """Handle chat completions for rotations using model name to select rotation"""
+    logger.info(f"=== ROTATION CHAT COMPLETION REQUEST START ===")
+    logger.info(f"Request path: {request.url.path}")
+    logger.info(f"Model requested: {body.model}")
+    logger.info(f"Request headers: {dict(request.headers)}")
+    logger.info(f"Request body: {body}")
+    logger.info(f"Available rotations: {list(config.rotations.keys())}")
+
+    body_dict = body.model_dump()
+
+    # Check if the model name corresponds to a rotation
+    if body.model not in config.rotations:
+        logger.error(f"Model '{body.model}' not found in rotations")
+        logger.error(f"Available rotations: {list(config.rotations.keys())}")
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model '{body.model}' not found. Available rotations: {list(config.rotations.keys())}"
+        )
+
+    logger.info(f"Model '{body.model}' found in rotations")
+    logger.debug("Handling rotation request")
+
+    try:
+        if body.stream:
+            logger.debug("Handling streaming rotation request")
+            return await rotation_handler.handle_rotation_request(body.model, body_dict)
+        else:
+            logger.debug("Handling non-streaming rotation request")
+            result = await rotation_handler.handle_rotation_request(body.model, body_dict)
+            logger.debug(f"Rotation response result: {result}")
+            return result
+    except Exception as e:
+        logger.error(f"Error handling rotation chat_completions: {str(e)}", exc_info=True)
+        raise
+
+@app.get("/api/rotations/models")
+async def list_rotation_models():
+    """List all models across all rotations"""
+    logger.info("=== LIST ROTATION MODELS REQUEST ===")
+    all_models = []
+    for rotation_id, rotation_config in config.rotations.items():
+        for provider in rotation_config.providers:
+            for model in provider['models']:
+                all_models.append({
+                    "id": f"{rotation_id}/{model['name']}",
+                    "name": rotation_id,  # Use rotation name as the model name for selection
+                    "object": "model",
+                    "owned_by": provider['provider_id'],
+                    "rotation_id": rotation_id,
+                    "actual_model": model['name'],
+                    "provider_id": provider['provider_id'],
+                    "weight": model['weight'],
+                    "rate_limit": model.get('rate_limit')
+                })
+    logger.info(f"Total rotation models available: {len(all_models)}")
+    return {"data": all_models}
+
+@app.get("/api/autoselect")
+async def list_autoselect():
+    """List all available autoselect configurations"""
+    logger.info("=== LIST AUTOSELECT REQUEST ===")
+    autoselect_info = {}
+    for autoselect_id, autoselect_config in config.autoselect.items():
+        autoselect_info[autoselect_id] = {
+            "model_name": autoselect_config.model_name,
+            "description": autoselect_config.description,
+            "fallback": autoselect_config.fallback,
+            "available_models": [
+                {
+                    "model_id": m.model_id,
+                    "description": m.description
+                }
+                for m in autoselect_config.available_models
+            ]
+        }
+    logger.info(f"Available autoselect: {list(autoselect_info.keys())}")
+    return autoselect_info
+
+@app.post("/api/autoselect/chat/completions")
+async def autoselect_chat_completions(request: Request, body: ChatCompletionRequest):
+    """Handle chat completions for autoselect using model name to select autoselect configuration"""
+    logger.info(f"=== AUTOSELECT CHAT COMPLETION REQUEST START ===")
+    logger.info(f"Request path: {request.url.path}")
+    logger.info(f"Model requested: {body.model}")
+    logger.info(f"Request headers: {dict(request.headers)}")
+    logger.info(f"Request body: {body}")
+    logger.info(f"Available autoselect: {list(config.autoselect.keys())}")
+
+    body_dict = body.model_dump()
+
+    # Check if the model name corresponds to an autoselect configuration
+    if body.model not in config.autoselect:
+        logger.error(f"Model '{body.model}' not found in autoselect")
+        logger.error(f"Available autoselect: {list(config.autoselect.keys())}")
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model '{body.model}' not found. Available autoselect: {list(config.autoselect.keys())}"
+        )
+
+    logger.info(f"Model '{body.model}' found in autoselect")
+    logger.debug("Handling autoselect request")
+
+    try:
+        if body.stream:
+            logger.debug("Handling streaming autoselect request")
+            return await autoselect_handler.handle_autoselect_streaming_request(body.model, body_dict)
+        else:
+            logger.debug("Handling non-streaming autoselect request")
+            result = await autoselect_handler.handle_autoselect_request(body.model, body_dict)
+            logger.debug(f"Autoselect response result: {result}")
+            return result
+    except Exception as e:
+        logger.error(f"Error handling autoselect chat_completions: {str(e)}", exc_info=True)
+        raise
+
+@app.get("/api/autoselect/models")
+async def list_autoselect_models():
+    """List all models across all autoselect configurations"""
+    logger.info("=== LIST AUTOSELECT MODELS REQUEST ===")
+    all_models = []
+    for autoselect_id, autoselect_config in config.autoselect.items():
+        for model_info in autoselect_config.available_models:
+            all_models.append({
+                "id": model_info.model_id,
+                "name": autoselect_id,  # Use autoselect name as the model name for selection
+                "object": "model",
+                "owned_by": "autoselect",
+                "autoselect_id": autoselect_id,
+                "description": model_info.description,
+                "fallback": autoselect_config.fallback
+            })
+    logger.info(f"Total autoselect models available: {len(all_models)}")
+    return {"data": all_models}
+
+@app.post("/api/{provider_id}/chat/completions")
+async def chat_completions(provider_id: str, request: Request, body: ChatCompletionRequest):
+    logger.info(f"=== CHAT COMPLETION REQUEST START ===")
+    logger.info(f"Request path: {request.url.path}")
+    logger.info(f"Provider ID: {provider_id}")
+    logger.info(f"Request headers: {dict(request.headers)}")
+    logger.info(f"Request body: {body}")
+    logger.info(f"Available providers: {list(config.providers.keys())}")
+    logger.info(f"Available rotations: {list(config.rotations.keys())}")
+    logger.info(f"Available autoselect: {list(config.autoselect.keys())}")
+    logger.debug(f"Request headers: {dict(request.headers)}")
+    logger.debug(f"Request body: {body}")
+
+    body_dict = body.model_dump()
+
+    # Check if it's an autoselect
+    if provider_id in config.autoselect:
+        logger.debug("Handling autoselect request")
+        try:
+            if body.stream:
+                logger.debug("Handling streaming autoselect request")
+                return await autoselect_handler.handle_autoselect_streaming_request(provider_id, body_dict)
+            else:
+                logger.debug("Handling non-streaming autoselect request")
+                result = await autoselect_handler.handle_autoselect_request(provider_id, body_dict)
+                logger.debug(f"Autoselect response result: {result}")
+                return result
+        except Exception as e:
+            logger.error(f"Error handling autoselect: {str(e)}", exc_info=True)
+            raise
+
+    # Check if it's a rotation
+    if provider_id in config.rotations:
+        logger.info(f"Provider ID '{provider_id}' found in rotations")
+        logger.debug("Handling rotation request")
+        return await rotation_handler.handle_rotation_request(provider_id, body_dict)
+
+    # Check if it's a provider
+    if provider_id not in config.providers:
+        logger.error(f"Provider ID '{provider_id}' not found in providers")
+        logger.error(f"Available providers: {list(config.providers.keys())}")
+        logger.error(f"Available rotations: {list(config.rotations.keys())}")
+        logger.error(f"Available autoselect: {list(config.autoselect.keys())}")
+        raise HTTPException(status_code=400, detail=f"Provider {provider_id} not found")
+    
+    logger.info(f"Provider ID '{provider_id}' found in providers")
+
+    provider_config = config.get_provider(provider_id)
+    logger.debug(f"Provider config: {provider_config}")
+
+    try:
+        if body.stream:
+            logger.debug("Handling streaming chat completion")
+            return await request_handler.handle_streaming_chat_completion(request, provider_id, body_dict)
+        else:
+            logger.debug("Handling non-streaming chat completion")
+            result = await request_handler.handle_chat_completion(request, provider_id, body_dict)
+            logger.debug(f"Response result: {result}")
+            return result
+    except Exception as e:
+        logger.error(f"Error handling chat_completions: {str(e)}", exc_info=True)
+        raise
+
+@app.get("/api/{provider_id}/models")
+async def list_models(request: Request, provider_id: str):
+    logger.debug(f"Received list_models request for provider: {provider_id}")
+
+    # Check if it's an autoselect
+    if provider_id in config.autoselect:
+        logger.debug("Handling autoselect model list request")
+        try:
+            result = await autoselect_handler.handle_autoselect_model_list(provider_id)
+            logger.debug(f"Autoselect models result: {result}")
+            return result
+        except Exception as e:
+            logger.error(f"Error handling autoselect model list: {str(e)}", exc_info=True)
+            raise
+
+    # Check if it's a rotation
+    if provider_id in config.rotations:
+        logger.info(f"Provider ID '{provider_id}' found in rotations")
+        logger.debug("Handling rotation model list request")
+        return await rotation_handler.handle_rotation_model_list(provider_id)
+
+    # Check if it's a provider
+    if provider_id not in config.providers:
+        logger.error(f"Provider ID '{provider_id}' not found in providers")
+        logger.error(f"Available providers: {list(config.providers.keys())}")
+        logger.error(f"Available rotations: {list(config.rotations.keys())}")
+        logger.error(f"Available autoselect: {list(config.autoselect.keys())}")
+        raise HTTPException(status_code=400, detail=f"Provider {provider_id} not found")
+    
+    logger.info(f"Provider ID '{provider_id}' found in providers")
+
+    provider_config = config.get_provider(provider_id)
+
+    try:
+        logger.debug("Handling model list request")
+        result = await request_handler.handle_model_list(request, provider_id)
+        logger.debug(f"Models result: {result}")
+        return result
+    except Exception as e:
+        logger.error(f"Error handling list_models: {str(e)}", exc_info=True)
+        raise
+
+@app.post("/api/{provider_id}")
+async def catch_all_post(provider_id: str, request: Request):
+    """Catch-all for POST requests to help debug routing issues"""
+    logger.info(f"=== CATCH-ALL POST REQUEST ===")
+    logger.info(f"Request path: {request.url.path}")
+    logger.info(f"Provider ID: {provider_id}")
+    logger.info(f"Request headers: {dict(request.headers)}")
+    logger.info(f"Available providers: {list(config.providers.keys())}")
+    logger.info(f"Available rotations: {list(config.rotations.keys())}")
+    logger.info(f"Available autoselect: {list(config.autoselect.keys())}")
+    
+    error_msg = f"""
+    Invalid endpoint: {request.url.path}
+    
+    The correct endpoint format is: /api/{{provider_id}}/chat/completions
+    
+    Available providers: {list(config.providers.keys())}
+    Available rotations: {list(config.rotations.keys())}
+    Available autoselect: {list(config.autoselect.keys())}
+    
+    Example: POST /api/ollama/chat/completions
+    """
+    logger.error(error_msg)
+    raise HTTPException(status_code=404, detail=error_msg.strip())
+
+def main():
+    """Main entry point for the AISBF server"""
+    import uvicorn
+    logger.info("Starting AI Proxy Server on http://localhost:8000")
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+if __name__ == "__main__":
+    main()

{aisbf-0.2.2.dist-info → aisbf-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisbf
-Version: 0.2.2
+Version: 0.2.4
 Summary: AISBF - AI Service Broker Framework || AI Should Be Free - A modular proxy server for managing multiple AI provider integrations
 Home-page: https://git.nexlab.net/nexlab/aisbf.git
 Author: AISBF Contributors

aisbf-0.2.4.dist-info/RECORD

@@ -0,0 +1,24 @@
+cli.py,sha256=SpjVC1iBdDhQXuhJcjVFkODu4BH-nj_1hNFD_d8wPbw,2503
+aisbf/__init__.py,sha256=D3-tZRWCu31CltN_pjx8IikwPl0OGEJkvoASm8QjvcQ,2156
+aisbf/config.py,sha256=xXcUQG3OcteCi8__qm6-yEnwjwFVpLBYLrs-zMnDfl0,9643
+aisbf/handlers.py,sha256=tXYOQYkhIK6X1EmgivVyO6fElkrRj1cqNQfQ5KGldO8,31557
+aisbf/models.py,sha256=LT1NaQVAw0VWXL-j3hdfNlXCA9HeiET_O3GDj3t9XC4,1883
+aisbf/providers.py,sha256=gh3qe-bthAxb-hRPPpp_YLgGzbdTKRN5HKVjf-Yvnp0,19920
+aisbf-0.2.4.data/data/share/aisbf/aisbf.sh,sha256=ntI4UPefBtU2jrTwMR3hddHEPG_pDyJyO0J3SD7e5PA,4574
+aisbf-0.2.4.data/data/share/aisbf/autoselect.json,sha256=Anud0hTE1mehonmMmhOTPK2ANUxfruE2yMdLqiEkEUA,659
+aisbf-0.2.4.data/data/share/aisbf/autoselect.md,sha256=F8PilhaYBs0qdpIxIkokrjtIOdhAx5Bi1tA0hyfnqps,4301
+aisbf-0.2.4.data/data/share/aisbf/main.py,sha256=hCTxLA-txJpSpMTE5mV1XG_j8Kn17ZTHJsnx59nKscg,17241
+aisbf-0.2.4.data/data/share/aisbf/providers.json,sha256=9L5GO6sQ2Z6zndGed0AckvYNV1DMr9r7tSdZ9fJxYlA,3934
+aisbf-0.2.4.data/data/share/aisbf/requirements.txt,sha256=lp6cPakAO3lpTCwQ27THf-PNz_HIpzCELrtpdgo6-2o,133
+aisbf-0.2.4.data/data/share/aisbf/rotations.json,sha256=SzbmMeTRR0vVTrYTMwxSPxjXLVr8zxjaI4HYRxjyExQ,2123
+aisbf-0.2.4.data/data/share/aisbf/aisbf/__init__.py,sha256=D3-tZRWCu31CltN_pjx8IikwPl0OGEJkvoASm8QjvcQ,2156
+aisbf-0.2.4.data/data/share/aisbf/aisbf/config.py,sha256=xXcUQG3OcteCi8__qm6-yEnwjwFVpLBYLrs-zMnDfl0,9643
+aisbf-0.2.4.data/data/share/aisbf/aisbf/handlers.py,sha256=tXYOQYkhIK6X1EmgivVyO6fElkrRj1cqNQfQ5KGldO8,31557
+aisbf-0.2.4.data/data/share/aisbf/aisbf/models.py,sha256=LT1NaQVAw0VWXL-j3hdfNlXCA9HeiET_O3GDj3t9XC4,1883
+aisbf-0.2.4.data/data/share/aisbf/aisbf/providers.py,sha256=gh3qe-bthAxb-hRPPpp_YLgGzbdTKRN5HKVjf-Yvnp0,19920
+aisbf-0.2.4.dist-info/licenses/LICENSE.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+aisbf-0.2.4.dist-info/METADATA,sha256=A_x1Mb5ryEHXXCKpdzfFz8Pgdn7FKgR4POzRKAmbdZU,4190
+aisbf-0.2.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aisbf-0.2.4.dist-info/entry_points.txt,sha256=dV_E5f6UvgSe9AoyPTzGxBK8IYaIeLR8yTe7EwBZ3F8,35
+aisbf-0.2.4.dist-info/top_level.txt,sha256=odXp1LYymu31EdVSmMGCg3ZYAI5HeB8tZkaXh9Pw3kE,10
+aisbf-0.2.4.dist-info/RECORD,,