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

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.2.data → aisbf-0.2.4.data}/data/share/aisbf/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,78 @@ 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())}")
+            
+            # Validate that all providers referenced in rotations exist
+            logger.info(f"=== VALIDATING ROTATION PROVIDERS ===")
+            available_providers = list(self.providers.keys())
+            logger.info(f"Available providers: {available_providers}")
+            
+            for rotation_id, rotation_config in self.rotations.items():
+                logger.info(f"Validating rotation: {rotation_id}")
+                for provider in rotation_config.providers:
+                    provider_id = provider['provider_id']
+                    if provider_id not in self.providers:
+                        logger.warning(f"!!! CONFIGURATION WARNING !!!")
+                        logger.warning(f"Rotation '{rotation_id}' references provider '{provider_id}' which is NOT defined in providers.json")
+                        logger.warning(f"Available providers: {available_providers}")
+                        logger.warning(f"This provider will be SKIPPED during rotation requests")
+                        logger.warning(f"Please add the provider to providers.json or remove it from the rotation configuration")
+                        logger.warning(f"!!! END WARNING !!!")
+                    else:
+                        logger.info(f"  ✓ Provider '{provider_id}' is available")
+            
+            logger.info(f"=== Config._load_rotations END ===")
 
     def _load_autoselect(self):
         autoselect_path = Path.home() / '.aisbf' / 'autoselect.json'
@@ -162,7 +209,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)