isa-model 0.3.8__tar.gz → 0.3.91__tar.gz

{isa_model-0.3.8 → isa_model-0.3.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isa_model
-Version: 0.3.8
+Version: 0.3.91
 Summary: Unified AI model serving framework
 Author: isA_Model Contributors
 Classifier: Development Status :: 3 - Alpha

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model/__init__.py

@@ -6,7 +6,7 @@ Main Components:
 - AIFactory: Legacy factory pattern (still supported)
 """
 
-__version__ = "0.3.5"
+__version__ = "0.3.91"
 
 # Main unified client interface
 from isa_model.client import ISAModelClient, create_client

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model/client.py

@@ -522,11 +522,28 @@ class ISAModelClient:
         unified_task = task_mapping.get(task, task)
         
         # Use unified invoke method
-        return await service.invoke(
+        result = await service.invoke(
             input_data=input_data,
             task=unified_task,
             **kwargs
         )
+        
+        # Handle the new response format from LLM services
+        # LLM services now return {"message": ..., "success": ..., "metadata": ...}
+        if isinstance(result, dict) and "message" in result:
+            # Extract the message content (convert AIMessage to string)
+            message = result["message"]
+            if hasattr(message, 'content'):
+                # Handle langchain AIMessage objects
+                return message.content
+            elif isinstance(message, str):
+                return message
+            else:
+                # Fallback: convert to string
+                return str(message)
+        
+        # Fallback for other service types or legacy format
+        return result
     
     async def _execute_image_task(self, service, input_data, task, **kwargs):
         """Execute image generation tasks using unified invoke method"""

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model/core/pricing_manager.py

@@ -15,6 +15,7 @@ from datetime import datetime, timedelta
 from dataclasses import dataclass, field
 
 from .types import Provider
+from .config import config_manager
 
 logger = logging.getLogger(__name__)
 
@@ -77,7 +78,17 @@ class PricingManager:
     
     def _load_pricing_data(self):
         """Load pricing data from configuration files"""
-        # Try to load from specified config path first
+        # Try to load from Supabase first
+        if self._load_from_supabase():
+            logger.info("Loaded pricing data from Supabase")
+            return
+        
+        # Try to load from provider configurations
+        if self._load_from_provider_configs():
+            logger.info("Loaded pricing data from provider configurations")
+            return
+        
+        # Try to load from specified config path
         if self.config_path and self.config_path.exists():
             self._load_from_file(self.config_path)
             return
@@ -187,6 +198,242 @@ class PricingManager:
         self._parse_pricing_data({"providers": default_pricing})
         logger.info("Loaded default pricing data")
     
+    def _load_from_supabase(self) -> bool:
+        """Try to load pricing data from Supabase models table"""
+        try:
+            global_config = config_manager.get_global_config()
+            if not global_config.use_supabase:
+                return False
+            
+            # Import Supabase client
+            try:
+                from supabase import create_client, Client
+            except ImportError:
+                logger.debug("Supabase library not available")
+                return False
+            
+            # Get Supabase credentials
+            supabase_url = global_config.supabase_url or os.getenv('SUPABASE_URL')
+            supabase_key = global_config.supabase_key or os.getenv('SUPABASE_ANON_KEY')
+            
+            if not supabase_url or not supabase_key:
+                logger.debug("Supabase credentials not configured")
+                return False
+            
+            # Create Supabase client
+            supabase: Client = create_client(supabase_url, supabase_key)
+            
+            # Query models table for pricing information
+            result = supabase.table('models').select('model_id, provider, metadata').execute()
+            
+            if not result.data:
+                logger.debug("No models found in Supabase")
+                return False
+            
+            self.pricing_data = {}
+            loaded_count = 0
+            
+            for model_record in result.data:
+                model_id = model_record.get('model_id')
+                provider = model_record.get('provider')
+                metadata = model_record.get('metadata', {})
+                
+                if not model_id or not provider:
+                    continue
+                
+                # Extract pricing from metadata
+                pricing = self._extract_pricing_from_supabase_metadata(metadata, provider, model_id)
+                if pricing:
+                    if provider not in self.pricing_data:
+                        self.pricing_data[provider] = {}
+                    self.pricing_data[provider][model_id] = pricing
+                    loaded_count += 1
+            
+            if loaded_count > 0:
+                logger.info(f"Loaded pricing for {loaded_count} models from Supabase")
+                return True
+            else:
+                logger.debug("No pricing data found in Supabase models")
+                return False
+            
+        except Exception as e:
+            logger.debug(f"Failed to load pricing from Supabase: {e}")
+            return False
+    
+    def _load_from_provider_configs(self) -> bool:
+        """Load pricing data from provider configuration files"""
+        try:
+            providers_dir = self._find_project_root() / "isa_model" / "core" / "config" / "providers"
+            if not providers_dir.exists():
+                return False
+            
+            self.pricing_data = {}
+            loaded_any = False
+            
+            # Load all provider config files
+            for config_file in providers_dir.glob("*.yaml"):
+                if self._load_provider_config_file(config_file):
+                    loaded_any = True
+            
+            return loaded_any
+            
+        except Exception as e:
+            logger.error(f"Failed to load pricing from provider configs: {e}")
+            return False
+    
+    def _load_provider_config_file(self, config_file: Path) -> bool:
+        """Load pricing data from a single provider config file"""
+        try:
+            with open(config_file, 'r') as f:
+                provider_data = yaml.safe_load(f)
+            
+            provider_name = provider_data.get("provider")
+            if not provider_name:
+                return False
+            
+            models = provider_data.get("models", [])
+            if not models:
+                return False
+            
+            self.pricing_data[provider_name] = {}
+            
+            for model in models:
+                model_id = model.get("model_id")
+                metadata = model.get("metadata", {})
+                
+                if not model_id:
+                    continue
+                
+                # Extract pricing information from metadata
+                pricing = self._extract_pricing_from_metadata(metadata, provider_name, model_id)
+                if pricing:
+                    self.pricing_data[provider_name][model_id] = pricing
+            
+            logger.debug(f"Loaded pricing for {len(self.pricing_data[provider_name])} models from {provider_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to load provider config {config_file}: {e}")
+            return False
+    
+    def _extract_pricing_from_metadata(self, metadata: Dict[str, Any], provider: str, model_name: str) -> Optional[ModelPricing]:
+        """Extract pricing information from model metadata"""
+        try:
+            # Map different pricing field formats to our standard format
+            pricing_fields = {
+                "cost_per_1000_chars": ("character", 1000),
+                "cost_per_1000_tokens": ("token", 1000000),  # Convert to cost per 1M tokens
+                "cost_per_minute": ("minute", 1),
+                "cost_per_image": ("image", 1),
+                "cost_per_request": ("request", 1),
+            }
+            
+            input_cost = 0.0
+            output_cost = 0.0
+            unit_type = "token"
+            base_cost = 0.0
+            
+            for field, (unit, multiplier) in pricing_fields.items():
+                if field in metadata:
+                    cost = float(metadata[field])
+                    if unit == "character":
+                        # Convert cost per 1K chars to cost per 1K chars
+                        input_cost = cost
+                        unit_type = "character"
+                    elif unit == "token":
+                        # Cost per 1M tokens
+                        input_cost = cost
+                        unit_type = "token"
+                    elif unit == "minute":
+                        input_cost = cost
+                        unit_type = "minute"
+                    elif unit == "image":
+                        input_cost = cost
+                        unit_type = "image"
+                    elif unit == "request":
+                        base_cost = cost
+                    break
+            
+            # If no pricing found, skip this model
+            if input_cost == 0.0 and base_cost == 0.0:
+                return None
+            
+            return ModelPricing(
+                provider=provider,
+                model_name=model_name,
+                input_cost=input_cost,
+                output_cost=output_cost,
+                unit_type=unit_type,
+                base_cost=base_cost,
+                last_updated=datetime.now()
+            )
+            
+        except Exception as e:
+            logger.warning(f"Failed to extract pricing for {provider}/{model_name}: {e}")
+            return None
+    
+    def _extract_pricing_from_supabase_metadata(self, metadata: Dict[str, Any], provider: str, model_name: str) -> Optional[ModelPricing]:
+        """Extract pricing information from Supabase model metadata"""
+        try:
+            # Check for pricing information in metadata
+            pricing_info = metadata.get('pricing', {})
+            
+            # If no pricing object, look for direct pricing fields
+            if not pricing_info:
+                # Look for various pricing field formats in metadata
+                pricing_fields = [
+                    'cost_per_1000_chars', 'cost_per_1000_tokens', 'cost_per_minute', 
+                    'cost_per_image', 'cost_per_request', 'input_cost', 'output_cost',
+                    'cost_per_1k_tokens', 'cost_per_1k_chars'
+                ]
+                
+                for field in pricing_fields:
+                    if field in metadata:
+                        # Create a pricing object from the field
+                        if 'char' in field:
+                            pricing_info = {'input': metadata[field], 'unit_type': 'character'}
+                        elif 'token' in field:
+                            pricing_info = {'input': metadata[field], 'unit_type': 'token'}
+                        elif 'minute' in field:
+                            pricing_info = {'input': metadata[field], 'unit_type': 'minute'}
+                        elif 'image' in field:
+                            pricing_info = {'input': metadata[field], 'unit_type': 'image'}
+                        elif 'request' in field:
+                            pricing_info = {'base_cost': metadata[field], 'unit_type': 'request'}
+                        break
+            
+            if not pricing_info:
+                return None
+            
+            # Extract standard pricing fields
+            input_cost = float(pricing_info.get('input', pricing_info.get('input_cost', 0.0)))
+            output_cost = float(pricing_info.get('output', pricing_info.get('output_cost', 0.0)))
+            unit_type = pricing_info.get('unit_type', 'token')
+            base_cost = float(pricing_info.get('base_cost', 0.0))
+            infrastructure_cost_per_hour = float(pricing_info.get('infrastructure_cost_per_hour', 0.0))
+            currency = pricing_info.get('currency', 'USD')
+            
+            # If no pricing found, skip this model
+            if input_cost == 0.0 and output_cost == 0.0 and base_cost == 0.0:
+                return None
+            
+            return ModelPricing(
+                provider=provider,
+                model_name=model_name,
+                input_cost=input_cost,
+                output_cost=output_cost,
+                unit_type=unit_type,
+                base_cost=base_cost,
+                infrastructure_cost_per_hour=infrastructure_cost_per_hour,
+                currency=currency,
+                last_updated=datetime.now(),
+                metadata=pricing_info
+            )
+            
+        except Exception as e:
+            logger.warning(f"Failed to extract pricing from Supabase metadata for {provider}/{model_name}: {e}")
+            return None
+    
     def get_model_pricing(self, provider: str, model_name: str) -> Optional[ModelPricing]:
         """Get pricing information for a specific model"""
         self._refresh_if_needed()

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model/inference/services/llm/ollama_llm_service.py

@@ -140,6 +140,49 @@ class OllamaLLMService(BaseLLMService):
         """Use adapter manager to format response (consistent with OpenAI service)"""
         return self.adapter_manager.format_response(response, original_input)
     
+    async def chat(
+        self,
+        input_data: Union[str, List[Dict[str, str]], Any],
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Chat method that wraps ainvoke for compatibility with base class
+        
+        Args:
+            input_data: Input messages
+            max_tokens: Maximum tokens to generate
+            
+        Returns:
+            Dict containing chat response with properly formatted message object
+        """
+        try:
+            # Call ainvoke and get the response (already processed by adapter)
+            response = await self.ainvoke(input_data)
+            
+            # Return the response as-is (adapter already formatted it correctly)
+            # For LangChain inputs, this will be an AIMessage object
+            # For standard inputs, this will be a string
+            return {
+                "message": response,  # Use "message" to preserve object type
+                "success": True,
+                "metadata": {
+                    "model": self.model_name,
+                    "provider": self.provider_name,
+                    "max_tokens": max_tokens or self.max_tokens
+                }
+            }
+        except Exception as e:
+            logger.error(f"Chat method failed: {e}")
+            return {
+                "message": None,
+                "success": False,
+                "error": str(e),
+                "metadata": {
+                    "model": self.model_name,
+                    "provider": self.provider_name
+                }
+            }
+    
     
     async def _stream_response(self, payload: Dict[str, Any]) -> AsyncGenerator[str, None]:
         """Handle streaming responses"""

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model/inference/services/llm/openai_llm_service.py

@@ -269,15 +269,17 @@ class OpenAILLMService(BaseLLMService):
             max_tokens: Maximum tokens to generate
             
         Returns:
-            Dict containing chat response
+            Dict containing chat response with properly formatted message object
         """
         try:
-            # Call ainvoke and get the response
+            # Call ainvoke and get the response (already processed by adapter)
             response = await self.ainvoke(input_data)
             
-            # Return in expected format
+            # Return the response as-is (adapter already formatted it correctly)
+            # For LangChain inputs, this will be an AIMessage object
+            # For standard inputs, this will be a string
             return {
-                "text": response if isinstance(response, str) else str(response),
+                "message": response,  # Changed from "text" to "message" to preserve object
                 "success": True,
                 "metadata": {
                     "model": self.model_name,
@@ -288,7 +290,7 @@ class OpenAILLMService(BaseLLMService):
         except Exception as e:
             logger.error(f"Chat method failed: {e}")
             return {
-                "text": "",
+                "message": None,
                 "success": False,
                 "error": str(e),
                 "metadata": {

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model/inference/services/llm/yyds_llm_service.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Any, List, Union, AsyncGenerator
+from typing import Dict, Any, List, Union, AsyncGenerator, Optional
 
 # (�� OpenAI �
 from openai import AsyncOpenAI
@@ -249,6 +249,48 @@ class YydsLLMService(BaseLLMService):
             }
         }
     
+    async def chat(
+        self,
+        input_data: Union[str, List[Dict[str, str]], Any],
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Chat method that wraps ainvoke for compatibility with base class
+        
+        Args:
+            input_data: Input messages
+            max_tokens: Maximum tokens to generate
+            
+        Returns:
+            Dict containing chat response with properly formatted message object
+        """
+        try:
+            # Call ainvoke and get the response (already processed by adapter)
+            response = await self.ainvoke(input_data)
+            
+            # Return the response as-is (adapter already formatted it correctly)
+            # For LangChain inputs, this will be an AIMessage object
+            # For standard inputs, this will be a string
+            return {
+                "message": response,  # Use "message" to preserve object type
+                "success": True,
+                "metadata": {
+                    "model": self.model_name,
+                    "provider": self.provider_name,
+                    "max_tokens": max_tokens or self.max_tokens
+                }
+            }
+        except Exception as e:
+            logger.error(f"Chat method failed: {e}")
+            return {
+                "message": None,
+                "success": False,
+                "error": str(e),
+                "metadata": {
+                    "model": self.model_name,
+                    "provider": self.provider_name
+                }
+            }
         
     async def close(self):
         """Close the backend client"""

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isa_model
-Version: 0.3.8
+Version: 0.3.91
 Summary: Unified AI model serving framework
 Author: isA_Model Contributors
 Classifier: Development Status :: 3 - Alpha

{isa_model-0.3.8 → isa_model-0.3.91}/isa_model.egg-info/SOURCES.txt

@@ -142,5 +142,6 @@ isa_model/training/core/dataset.py
 isa_model/training/core/trainer.py
 isa_model/training/core/utils.py
 tests/test_cleaned_ai_factory.py
+tests/test_client_tools.py
 tests/test_isa_model_client.py
 tests/test_isa_model_client_http.py

{isa_model-0.3.8 → isa_model-0.3.91}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "isa_model"
-version = "0.3.8"
+version = "0.3.91"
 description = "Unified AI model serving framework"
 authors = [{name = "isA_Model Contributors"}]
 readme = "README.md"