aisbf 0.2.2__tar.gz → 0.2.3__tar.gz

{aisbf-0.2.2/aisbf.egg-info → aisbf-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisbf
-Version: 0.2.2
+Version: 0.2.3
 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.2 → aisbf-0.2.3}/aisbf/config.py

@@ -34,6 +34,7 @@ class ProviderConfig(BaseModel):
     endpoint: str
     type: str
     api_key_required: bool
+    rate_limit: float = 0.0
 
 class RotationConfig(BaseModel):
     providers: List[Dict]
@@ -111,32 +112,58 @@ class Config:
                 print(f"Created default config file: {dst}")
 
     def _load_providers(self):
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== Config._load_providers START ===")
+        
         providers_path = Path.home() / '.aisbf' / 'providers.json'
+        logger.info(f"Looking for providers at: {providers_path}")
+        
         if not providers_path.exists():
+            logger.info(f"User config not found, falling back to source config")
             # Fallback to source config if user config doesn't exist
             try:
                 source_dir = self._get_config_source_dir()
                 providers_path = source_dir / 'providers.json'
+                logger.info(f"Using source config at: {providers_path}")
             except FileNotFoundError:
+                logger.error("Could not find providers.json configuration file")
                 raise FileNotFoundError("Could not find providers.json configuration file")
         
+        logger.info(f"Loading providers from: {providers_path}")
         with open(providers_path) as f:
             data = json.load(f)
             self.providers = {k: ProviderConfig(**v) for k, v in data['providers'].items()}
+            logger.info(f"Loaded {len(self.providers)} providers: {list(self.providers.keys())}")
+            for provider_id, provider_config in self.providers.items():
+                logger.info(f"  - {provider_id}: type={provider_config.type}, endpoint={provider_config.endpoint}")
+            logger.info(f"=== Config._load_providers END ===")
 
     def _load_rotations(self):
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== Config._load_rotations START ===")
+        
         rotations_path = Path.home() / '.aisbf' / 'rotations.json'
+        logger.info(f"Looking for rotations at: {rotations_path}")
+        
         if not rotations_path.exists():
+            logger.info(f"User config not found, falling back to source config")
             # Fallback to source config if user config doesn't exist
             try:
                 source_dir = self._get_config_source_dir()
                 rotations_path = source_dir / 'rotations.json'
+                logger.info(f"Using source config at: {rotations_path}")
             except FileNotFoundError:
+                logger.error("Could not find rotations.json configuration file")
                 raise FileNotFoundError("Could not find rotations.json configuration file")
         
+        logger.info(f"Loading rotations from: {rotations_path}")
         with open(rotations_path) as f:
             data = json.load(f)
             self.rotations = {k: RotationConfig(**v) for k, v in data['rotations'].items()}
+            logger.info(f"Loaded {len(self.rotations)} rotations: {list(self.rotations.keys())}")
+            logger.info(f"=== Config._load_rotations END ===")
 
     def _load_autoselect(self):
         autoselect_path = Path.home() / '.aisbf' / 'autoselect.json'
@@ -162,7 +189,16 @@ class Config:
             }
 
     def get_provider(self, provider_id: str) -> ProviderConfig:
-        return self.providers.get(provider_id)
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"Config.get_provider called with provider_id: {provider_id}")
+        logger.info(f"Available providers: {list(self.providers.keys())}")
+        result = self.providers.get(provider_id)
+        if result:
+            logger.info(f"Found provider: {result}")
+        else:
+            logger.warning(f"Provider {provider_id} not found!")
+        return result
 
     def get_rotation(self, rotation_id: str) -> RotationConfig:
         return self.rotations.get(rotation_id)

{aisbf-0.2.2 → aisbf-0.2.3}/aisbf/handlers.py

@@ -37,24 +37,47 @@ class RequestHandler:
         self.config = config
 
     async def handle_chat_completion(self, request: Request, provider_id: str, request_data: Dict) -> Dict:
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== RequestHandler.handle_chat_completion START ===")
+        logger.info(f"Provider ID: {provider_id}")
+        logger.info(f"Request data: {request_data}")
+        
         provider_config = self.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}")
+        logger.info(f"API key required: {provider_config.api_key_required}")
 
         if provider_config.api_key_required:
             api_key = request_data.get('api_key') or request.headers.get('Authorization', '').replace('Bearer ', '')
+            logger.info(f"API key from request: {'***' if api_key else 'None'}")
             if not api_key:
                 raise HTTPException(status_code=401, detail="API key required")
         else:
             api_key = None
+            logger.info("No API key required for this provider")
 
+        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="Provider temporarily unavailable")
 
         try:
+            logger.info(f"Model requested: {request_data.get('model')}")
+            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
+            logger.info("Applying rate limiting...")
             await handler.apply_rate_limit()
+            logger.info("Rate limiting applied")
 
+            logger.info(f"Sending request to provider handler...")
             response = await handler.handle_request(
                 model=request_data['model'],
                 messages=request_data['messages'],
@@ -62,7 +85,9 @@ class RequestHandler:
                 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"=== RequestHandler.handle_chat_completion END ===")
             return response
         except Exception as e:
             handler.record_failure()
@@ -129,37 +154,67 @@ class RotationHandler:
         self.config = config
 
     async def handle_rotation_request(self, rotation_id: str, request_data: Dict) -> Dict:
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"=== RotationHandler.handle_rotation_request START ===")
+        logger.info(f"Rotation ID: {rotation_id}")
+        
         rotation_config = self.config.get_rotation(rotation_id)
         if not rotation_config:
+            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}")
         providers = rotation_config.providers
+        logger.info(f"Number of providers in rotation: {len(providers)}")
+        
         weighted_models = []
 
         for provider in providers:
+            logger.info(f"Processing provider: {provider['provider_id']}")
             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")
 
         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']
+        
+        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)}")
+            
             # 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")
 
+            logger.info(f"Sending request to provider handler...")
             response = await handler.handle_request(
                 model=model_name,
                 messages=request_data['messages'],
@@ -167,7 +222,9 @@ class RotationHandler:
                 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()

{aisbf-0.2.2 → aisbf-0.2.3}/aisbf/providers.py

@@ -249,30 +249,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 +386,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.2 → aisbf-0.2.3/aisbf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisbf
-Version: 0.2.2
+Version: 0.2.3
 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.2 → aisbf-0.2.3}/main.py

@@ -120,7 +120,14 @@ async def root():
 
 @app.post("/api/{provider_id}/chat/completions")
 async def chat_completions(provider_id: str, request: Request, body: ChatCompletionRequest):
-    logger.debug(f"Received chat_completions request for provider: {provider_id}")
+    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}")
 
@@ -144,13 +151,19 @@ async def chat_completions(provider_id: str, request: Request, body: ChatComplet
 
     # 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 {provider_id} not found")
+        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}")
@@ -185,13 +198,19 @@ async def list_models(request: Request, provider_id: str):
 
     # 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 {provider_id} not found")
+        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)
 
@@ -204,6 +223,31 @@ async def list_models(request: Request, provider_id: str):
         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

{aisbf-0.2.2 → aisbf-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aisbf"
-version = "0.2.2"
+version = "0.2.3"
 description = "AISBF - AI Service Broker Framework || AI Should Be Free - A modular proxy server for managing multiple AI provider integrations"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{aisbf-0.2.2 → aisbf-0.2.3}/setup.py

@@ -49,7 +49,7 @@ class InstallCommand(_install):
 
 setup(
     name="aisbf",
-    version="0.2.2",
+    version="0.2.3",
     author="AISBF Contributors",
     author_email="stefy@nexlab.net",
     description="AISBF - AI Service Broker Framework || AI Should Be Free - A modular proxy server for managing multiple AI provider integrations",