aisbf 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

aisbf/__init__.py

@@ -23,7 +23,7 @@ Why did the programmer quit his job? Because he didn't get arrays!
 A modular proxy server for managing multiple AI provider integrations.
 """
 
-from .config import config, Config, ProviderConfig, RotationConfig, AppConfig
+from .config import config, Config, ProviderConfig, RotationConfig, AppConfig, AutoselectConfig, AutoselectModelInfo
 from .models import (
     Message,
     ChatCompletionRequest,
@@ -41,7 +41,7 @@ from .providers import (
     get_provider_handler,
     PROVIDER_HANDLERS
 )
-from .handlers import RequestHandler, RotationHandler
+from .handlers import RequestHandler, RotationHandler, AutoselectHandler
 
 __version__ = "0.1.0"
 __all__ = [
@@ -51,6 +51,8 @@ __all__ = [
     "ProviderConfig",
     "RotationConfig",
     "AppConfig",
+    "AutoselectConfig",
+    "AutoselectModelInfo",
     # Models
     "Message",
     "ChatCompletionRequest",
@@ -58,6 +60,8 @@ __all__ = [
     "Model",
     "Provider",
     "ErrorTracking",
+    "AutoselectModelInfo",
+    "AutoselectConfig",
     # Providers
     "BaseProviderHandler",
     "GoogleProviderHandler",
@@ -69,4 +73,5 @@ __all__ = [
     # Handlers
     "RequestHandler",
     "RotationHandler",
+    "AutoselectHandler",
 ]

aisbf/config.py

@@ -38,9 +38,20 @@ class ProviderConfig(BaseModel):
 class RotationConfig(BaseModel):
     providers: List[Dict]
 
+class AutoselectModelInfo(BaseModel):
+    model_id: str
+    description: str
+
+class AutoselectConfig(BaseModel):
+    model_name: str
+    description: str
+    fallback: str
+    available_models: List[AutoselectModelInfo]
+
 class AppConfig(BaseModel):
     providers: Dict[str, ProviderConfig]
     rotations: Dict[str, RotationConfig]
+    autoselect: Dict[str, AutoselectConfig]
     error_tracking: Dict[str, Dict]
 
 class Config:
@@ -48,13 +59,14 @@ class Config:
         self._ensure_config_directory()
         self._load_providers()
         self._load_rotations()
+        self._load_autoselect()
         self._initialize_error_tracking()
 
     def _get_config_source_dir(self):
         """Get the directory containing default config files"""
         # Try installed location first
         installed_dirs = [
-            Path('/usr/local/share/aisbf'),
+            Path('/usr/share/aisbf'),
             Path.home() / '.local' / 'share' / 'aisbf',
         ]
         
@@ -64,7 +76,7 @@ class Config:
         
         # Fallback to source tree config directory
         # This is for development mode
-        source_dir = Path(__file__).parent.parent.parent / 'config'
+        source_dir = Path(__file__).parent.parent / 'config'
         if source_dir.exists() and (source_dir / 'providers.json').exists():
             return source_dir
         
@@ -90,7 +102,7 @@ class Config:
             return
         
         # Copy default config files if they don't exist
-        for config_file in ['providers.json', 'rotations.json']:
+        for config_file in ['providers.json', 'rotations.json', 'autoselect.json']:
             src = source_dir / config_file
             dst = config_dir / config_file
             
@@ -126,6 +138,20 @@ class Config:
             data = json.load(f)
             self.rotations = {k: RotationConfig(**v) for k, v in data['rotations'].items()}
 
+    def _load_autoselect(self):
+        autoselect_path = Path.home() / '.aisbf' / 'autoselect.json'
+        if not autoselect_path.exists():
+            # Fallback to source config if user config doesn't exist
+            try:
+                source_dir = self._get_config_source_dir()
+                autoselect_path = source_dir / 'autoselect.json'
+            except FileNotFoundError:
+                raise FileNotFoundError("Could not find autoselect.json configuration file")
+        
+        with open(autoselect_path) as f:
+            data = json.load(f)
+            self.autoselect = {k: AutoselectConfig(**v) for k, v in data.items()}
+
     def _initialize_error_tracking(self):
         self.error_tracking = {}
         for provider_id in self.providers:
@@ -141,4 +167,7 @@ class Config:
     def get_rotation(self, rotation_id: str) -> RotationConfig:
         return self.rotations.get(rotation_id)
 
+    def get_autoselect(self, autoselect_id: str) -> AutoselectConfig:
+        return self.autoselect.get(autoselect_id)
+
 config = Config()

aisbf/handlers.py

@@ -23,7 +23,9 @@ Why did the programmer quit his job? Because he didn't get arrays!
 Request handlers for AISBF.
 """
 import asyncio
+import re
 from typing import Dict, List, Optional
+from pathlib import Path
 from fastapi import HTTPException, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 from .models import ChatCompletionRequest, ChatCompletionResponse
@@ -188,3 +190,194 @@ class RotationHandler:
                 })
 
         return all_models
+
+class AutoselectHandler:
+    def __init__(self):
+        self.config = config
+        self._skill_file_content = None
+
+    def _get_skill_file_content(self) -> str:
+        """Load the autoselect.md skill file content"""
+        if self._skill_file_content is None:
+            # Try installed locations first
+            installed_dirs = [
+                Path('/usr/share/aisbf'),
+                Path.home() / '.local' / 'share' / 'aisbf',
+            ]
+            
+            for installed_dir in installed_dirs:
+                skill_file = installed_dir / 'autoselect.md'
+                if skill_file.exists():
+                    with open(skill_file) as f:
+                        self._skill_file_content = f.read()
+                    return self._skill_file_content
+            
+            # Fallback to source tree config directory
+            source_dir = Path(__file__).parent.parent / 'config'
+            skill_file = source_dir / 'autoselect.md'
+            if skill_file.exists():
+                with open(skill_file) as f:
+                    self._skill_file_content = f.read()
+                return self._skill_file_content
+            
+            raise FileNotFoundError("Could not find autoselect.md skill file")
+        
+        return self._skill_file_content
+
+    def _build_autoselect_prompt(self, user_prompt: str, autoselect_config) -> str:
+        """Build the prompt for model selection"""
+        skill_content = self._get_skill_file_content()
+        
+        # Build the available models list
+        models_list = ""
+        for model_info in autoselect_config.available_models:
+            models_list += f"<model><model_id>{model_info.model_id}</model_id><model_description>{model_info.description}</model_description></model>\n"
+        
+        # Build the complete prompt
+        prompt = f"""{skill_content}
+
+<aisbf_user_prompt>{user_prompt}</aisbf_user_prompt>
+<aisbf_autoselect_list>
+{models_list}
+</aisbf_autoselect_list>
+<aisbf_autoselect_fallback>{autoselect_config.fallback}</aisbf_autoselect_fallback>
+"""
+        return prompt
+
+    def _extract_model_selection(self, response: str) -> Optional[str]:
+        """Extract the model_id from the autoselection response"""
+        match = re.search(r'<aisbf_model_autoselection>(.*?)</aisbf_model_autoselection>', response, re.DOTALL)
+        if match:
+            return match.group(1).strip()
+        return None
+
+    async def _get_model_selection(self, prompt: str) -> str:
+        """Send the autoselect prompt to a model and get the 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()
+        
+        # Create a minimal request for model selection
+        selection_request = {
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.1,  # Low temperature for more deterministic selection
+            "max_tokens": 100,   # We only need a short response
+            "stream": False
+        }
+        
+        # Use the fallback rotation for the selection
+        try:
+            response = await rotation_handler.handle_rotation_request("general", selection_request)
+            content = response.get('choices', [{}])[0].get('message', {}).get('content', '')
+            model_id = self._extract_model_selection(content)
+            return model_id
+        except Exception as e:
+            # 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"""
+        autoselect_config = self.config.get_autoselect(autoselect_id)
+        if not autoselect_config:
+            raise HTTPException(status_code=400, detail=f"Autoselect {autoselect_id} not found")
+
+        # Extract the user prompt from the request
+        user_messages = request_data.get('messages', [])
+        if not user_messages:
+            raise HTTPException(status_code=400, detail="No messages provided")
+        
+        # Build a string representation of the user prompt
+        user_prompt = ""
+        for msg in user_messages:
+            role = msg.get('role', 'user')
+            content = msg.get('content', '')
+            if isinstance(content, list):
+                # Handle complex content (e.g., with images)
+                content = str(content)
+            user_prompt += f"{role}: {content}\n"
+
+        # Build the autoselect prompt
+        autoselect_prompt = self._build_autoselect_prompt(user_prompt, autoselect_config)
+
+        # Get the model selection
+        selected_model_id = await self._get_model_selection(autoselect_prompt)
+
+        # Validate the selected model
+        if not selected_model_id:
+            # Fallback to the configured fallback model
+            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:
+                selected_model_id = autoselect_config.fallback
+
+        # Now proxy the actual request to the selected rotation
+        rotation_handler = RotationHandler()
+        return await rotation_handler.handle_rotation_request(selected_model_id, request_data)
+
+    async def handle_autoselect_streaming_request(self, autoselect_id: str, request_data: Dict):
+        """Handle an autoselect streaming request"""
+        autoselect_config = self.config.get_autoselect(autoselect_id)
+        if not autoselect_config:
+            raise HTTPException(status_code=400, detail=f"Autoselect {autoselect_id} not found")
+
+        # Extract the user prompt from the request
+        user_messages = request_data.get('messages', [])
+        if not user_messages:
+            raise HTTPException(status_code=400, detail="No messages provided")
+        
+        # Build a string representation of the user prompt
+        user_prompt = ""
+        for msg in user_messages:
+            role = msg.get('role', 'user')
+            content = msg.get('content', '')
+            if isinstance(content, list):
+                content = str(content)
+            user_prompt += f"{role}: {content}\n"
+
+        # Build the autoselect prompt
+        autoselect_prompt = self._build_autoselect_prompt(user_prompt, autoselect_config)
+
+        # Get the model selection
+        selected_model_id = await self._get_model_selection(autoselect_prompt)
+
+        # Validate the selected model
+        if not selected_model_id:
+            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:
+                selected_model_id = autoselect_config.fallback
+
+        # Now proxy the actual streaming request to the selected rotation
+        rotation_handler = RotationHandler()
+        
+        async def stream_generator():
+            try:
+                response = await rotation_handler.handle_rotation_request(
+                    selected_model_id,
+                    {**request_data, "stream": True}
+                )
+                for chunk in response:
+                    yield f"data: {chunk}\n\n".encode('utf-8')
+            except Exception as e:
+                yield f"data: {str(e)}\n\n".encode('utf-8')
+
+        return StreamingResponse(stream_generator(), media_type="text/event-stream")
+
+    async def handle_autoselect_model_list(self, autoselect_id: str) -> List[Dict]:
+        """List available models for an autoselect endpoint"""
+        autoselect_config = self.config.get_autoselect(autoselect_id)
+        if not autoselect_config:
+            raise HTTPException(status_code=400, detail=f"Autoselect {autoselect_id} not found")
+
+        # Return the available models that can be selected
+        return [
+            {
+                "id": model_info.model_id,
+                "name": model_info.model_id,
+                "description": model_info.description
+            }
+            for model_info in autoselect_config.available_models
+        ]

aisbf-0.2.0.data/data/share/aisbf/aisbf/__init__.py

@@ -0,0 +1,77 @@
+"""
+Copyleft (C) 2026 Stefy Lanza <stefy@nexlab.net>
+
+AISBF - AI Service Broker Framework || AI Should Be Free
+
+A modular proxy server for managing multiple AI provider integrations.
+
+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!
+
+A modular proxy server for managing multiple AI provider integrations.
+"""
+
+from .config import config, Config, ProviderConfig, RotationConfig, AppConfig, AutoselectConfig, AutoselectModelInfo
+from .models import (
+    Message,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    Model,
+    Provider,
+    ErrorTracking
+)
+from .providers import (
+    BaseProviderHandler,
+    GoogleProviderHandler,
+    OpenAIProviderHandler,
+    AnthropicProviderHandler,
+    OllamaProviderHandler,
+    get_provider_handler,
+    PROVIDER_HANDLERS
+)
+from .handlers import RequestHandler, RotationHandler, AutoselectHandler
+
+__version__ = "0.1.0"
+__all__ = [
+    # Config
+    "config",
+    "Config",
+    "ProviderConfig",
+    "RotationConfig",
+    "AppConfig",
+    "AutoselectConfig",
+    "AutoselectModelInfo",
+    # Models
+    "Message",
+    "ChatCompletionRequest",
+    "ChatCompletionResponse",
+    "Model",
+    "Provider",
+    "ErrorTracking",
+    "AutoselectModelInfo",
+    "AutoselectConfig",
+    # Providers
+    "BaseProviderHandler",
+    "GoogleProviderHandler",
+    "OpenAIProviderHandler",
+    "AnthropicProviderHandler",
+    "OllamaProviderHandler",
+    "get_provider_handler",
+    "PROVIDER_HANDLERS",
+    # Handlers
+    "RequestHandler",
+    "RotationHandler",
+    "AutoselectHandler",
+]

aisbf-0.2.0.data/data/share/aisbf/aisbf/config.py

@@ -0,0 +1,173 @@
+"""
+Copyleft (C) 2026 Stefy Lanza <stefy@nexlab.net>
+
+AISBF - AI Service Broker Framework || AI Should Be Free
+
+Configuration management 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!
+
+Configuration management for AISBF.
+"""
+from typing import Dict, List, Optional
+from pydantic import BaseModel, Field
+import json
+import shutil
+from pathlib import Path
+
+class ProviderConfig(BaseModel):
+    id: str
+    name: str
+    endpoint: str
+    type: str
+    api_key_required: bool
+
+class RotationConfig(BaseModel):
+    providers: List[Dict]
+
+class AutoselectModelInfo(BaseModel):
+    model_id: str
+    description: str
+
+class AutoselectConfig(BaseModel):
+    model_name: str
+    description: str
+    fallback: str
+    available_models: List[AutoselectModelInfo]
+
+class AppConfig(BaseModel):
+    providers: Dict[str, ProviderConfig]
+    rotations: Dict[str, RotationConfig]
+    autoselect: Dict[str, AutoselectConfig]
+    error_tracking: Dict[str, Dict]
+
+class Config:
+    def __init__(self):
+        self._ensure_config_directory()
+        self._load_providers()
+        self._load_rotations()
+        self._load_autoselect()
+        self._initialize_error_tracking()
+
+    def _get_config_source_dir(self):
+        """Get the directory containing default config files"""
+        # Try installed location first
+        installed_dirs = [
+            Path('/usr/share/aisbf'),
+            Path.home() / '.local' / 'share' / 'aisbf',
+        ]
+        
+        for installed_dir in installed_dirs:
+            if installed_dir.exists() and (installed_dir / 'providers.json').exists():
+                return installed_dir
+        
+        # Fallback to source tree config directory
+        # This is for development mode
+        source_dir = Path(__file__).parent.parent / 'config'
+        if source_dir.exists() and (source_dir / 'providers.json').exists():
+            return source_dir
+        
+        # Last resort: try the old location in the package directory
+        package_dir = Path(__file__).parent
+        if (package_dir / 'providers.json').exists():
+            return package_dir
+        
+        raise FileNotFoundError("Could not find configuration files")
+
+    def _ensure_config_directory(self):
+        """Ensure ~/.aisbf/ directory exists and copy default config files if needed"""
+        config_dir = Path.home() / '.aisbf'
+        
+        # Create config directory if it doesn't exist
+        config_dir.mkdir(exist_ok=True)
+        
+        # Get the source directory for default config files
+        try:
+            source_dir = self._get_config_source_dir()
+        except FileNotFoundError:
+            print("Warning: Could not find default configuration files")
+            return
+        
+        # Copy default config files if they don't exist
+        for config_file in ['providers.json', 'rotations.json', 'autoselect.json']:
+            src = source_dir / config_file
+            dst = config_dir / config_file
+            
+            if not dst.exists() and src.exists():
+                shutil.copy2(src, dst)
+                print(f"Created default config file: {dst}")
+
+    def _load_providers(self):
+        providers_path = Path.home() / '.aisbf' / 'providers.json'
+        if not providers_path.exists():
+            # Fallback to source config if user config doesn't exist
+            try:
+                source_dir = self._get_config_source_dir()
+                providers_path = source_dir / 'providers.json'
+            except FileNotFoundError:
+                raise FileNotFoundError("Could not find providers.json configuration file")
+        
+        with open(providers_path) as f:
+            data = json.load(f)
+            self.providers = {k: ProviderConfig(**v) for k, v in data['providers'].items()}
+
+    def _load_rotations(self):
+        rotations_path = Path.home() / '.aisbf' / 'rotations.json'
+        if not rotations_path.exists():
+            # Fallback to source config if user config doesn't exist
+            try:
+                source_dir = self._get_config_source_dir()
+                rotations_path = source_dir / 'rotations.json'
+            except FileNotFoundError:
+                raise FileNotFoundError("Could not find rotations.json configuration file")
+        
+        with open(rotations_path) as f:
+            data = json.load(f)
+            self.rotations = {k: RotationConfig(**v) for k, v in data['rotations'].items()}
+
+    def _load_autoselect(self):
+        autoselect_path = Path.home() / '.aisbf' / 'autoselect.json'
+        if not autoselect_path.exists():
+            # Fallback to source config if user config doesn't exist
+            try:
+                source_dir = self._get_config_source_dir()
+                autoselect_path = source_dir / 'autoselect.json'
+            except FileNotFoundError:
+                raise FileNotFoundError("Could not find autoselect.json configuration file")
+        
+        with open(autoselect_path) as f:
+            data = json.load(f)
+            self.autoselect = {k: AutoselectConfig(**v) for k, v in data.items()}
+
+    def _initialize_error_tracking(self):
+        self.error_tracking = {}
+        for provider_id in self.providers:
+            self.error_tracking[provider_id] = {
+                'failures': 0,
+                'last_failure': None,
+                'disabled_until': None
+            }
+
+    def get_provider(self, provider_id: str) -> ProviderConfig:
+        return self.providers.get(provider_id)
+
+    def get_rotation(self, rotation_id: str) -> RotationConfig:
+        return self.rotations.get(rotation_id)
+
+    def get_autoselect(self, autoselect_id: str) -> AutoselectConfig:
+        return self.autoselect.get(autoselect_id)
+
+config = Config()