isa-model 0.3.8__py3-none-any.whl → 0.3.91__py3-none-any.whl

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/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/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/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/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/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.dist-info → isa_model-0.3.91.dist-info}/METADATA

@@ -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.dist-info → isa_model-0.3.91.dist-info}/RECORD

@@ -1,7 +1,7 @@
-isa_model/__init__.py,sha256=bAbHdrDVQ-mySC_GJtgfLNI8KPcs2LfReBkIOOtpaQQ,867
-isa_model/client.py,sha256=oo2WcxElcD9WMtw6STj3vS9KwjI-DvS_ldqC1X-HRBs,35456
+isa_model/__init__.py,sha256=lYYKstKw33oavW6xS0-9cpsdYq-h0cfV_ZlGAwICRaU,868
+isa_model/client.py,sha256=CcVIAYI8_t-uyIJVyxF6obF2aDSbDmS23A_xykJaQgM,36184
 isa_model/core/config.py,sha256=h9GVTEEMlaJYSCDd0W9q1KtaWTV5V5TawMsKtGuphds,15686
-isa_model/core/pricing_manager.py,sha256=b7HcZsBQ8ZSCzMepOhqN-J9kU43vhTxX5NabQS0aM70,17125
+isa_model/core/pricing_manager.py,sha256=W9VRHGsJVxs3EcPD2zRP0lvOYlxydb6E74RS-sLn_UA,27745
 isa_model/core/types.py,sha256=XLUs442WGNc8E0gF2M-nb6dutD_s-XCfpr2BfGBCA2M,8445
 isa_model/core/config/__init__.py,sha256=SLeHQtYGDHl64NDVyb3ECQXOKepGM8YNHEoM8CVEWus,350
 isa_model/core/config/config_manager.py,sha256=hx0qcdvYEE_cCp-qb8tnVkXnpsTXEuRM1108DoAiUnE,19905
@@ -70,9 +70,9 @@ isa_model/inference/services/img/replicate_image_gen_service.py,sha256=QLjgrXNmt
 isa_model/inference/services/img/helpers/base_stacked_service.py,sha256=Y2g2Hz3n2Uwo4RoCbsC33IXxTeQ2TeT6T-2HnXd-2B0,10546
 isa_model/inference/services/llm/__init__.py,sha256=hSdfeqE0463CtQ6ZzREqPBvtzXNuzi3W5PFKS0nwhvo,336
 isa_model/inference/services/llm/base_llm_service.py,sha256=fg79J5mKy27qahvtLscMcquOe4O2L-EoNjE33yPRI9E,22196
-isa_model/inference/services/llm/ollama_llm_service.py,sha256=c0i9TLce6YcPlsLpj11kvwd-H2Uvw23G0ACuNShGyAM,16009
-isa_model/inference/services/llm/openai_llm_service.py,sha256=yhqsExCWvVs6G7EhwZnoXMtKncpwY1VPeZqgLibMSX0,11922
-isa_model/inference/services/llm/yyds_llm_service.py,sha256=WA5vwK9j7PrEEffdvP4thNwBlZ5Z13vFXX_F3Kd5V-Y,10475
+isa_model/inference/services/llm/ollama_llm_service.py,sha256=PfsMesjdtpqseLa2OUUg8WWyiIdIUhu9L5s5DkZl040,17580
+isa_model/inference/services/llm/openai_llm_service.py,sha256=40FYFb0bnVQrPwTg10CAKytKDj4zeZvp517do00Y_Ok,12174
+isa_model/inference/services/llm/yyds_llm_service.py,sha256=I8fBCd1dk56hlpnkToh-aAE77hP5YanHRVVEcXHYasE,12051
 isa_model/inference/services/llm/helpers/llm_adapter.py,sha256=gkKND55EoizRxsaGOCEazUmL-2yTIBI-_njpEOXt-4k,21779
 isa_model/inference/services/llm/helpers/llm_prompts.py,sha256=4ZOovr_Jx5bwPiMkgO1lZF7GMyEFbITP3ZrhhI48QMs,10964
 isa_model/inference/services/llm/helpers/llm_utils.py,sha256=LNfB3qzREyD2TyleOyVa20FU8HbhdxA8G6QV-N-wfZs,10016
@@ -132,7 +132,7 @@ isa_model/training/core/config.py,sha256=oqgKpBvtzrN6jwLIQYQ2707lH6nmjrktRiSxp9i
 isa_model/training/core/dataset.py,sha256=XCFsnf0NUMU1dJpdvo_CAMyvXB-9_RCUEiy8TU50e20,7802
 isa_model/training/core/trainer.py,sha256=h5TjqjdFr0Fsv5y4-0siy1KmOlqLfliVaUXybvuoeXU,26932
 isa_model/training/core/utils.py,sha256=Nik0M2ssfNbWqP6fKO0Kfyhzr_H6Q19ioxB-qCYbn5E,8387
-isa_model-0.3.8.dist-info/METADATA,sha256=rQ6RLtoPX1xoT2BFeRQZTx9gRSeCjRxuTbH3xseKbdE,12326
-isa_model-0.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isa_model-0.3.8.dist-info/top_level.txt,sha256=eHSy_Xb3kNkh2kK11mi1mZh0Wz91AQ5b8k2KFYO-rE8,10
-isa_model-0.3.8.dist-info/RECORD,,
+isa_model-0.3.91.dist-info/METADATA,sha256=FTukjTziEHQLyxLZ1HwYiqPgE353H1wPx1ReEX9TbNg,12327
+isa_model-0.3.91.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isa_model-0.3.91.dist-info/top_level.txt,sha256=eHSy_Xb3kNkh2kK11mi1mZh0Wz91AQ5b8k2KFYO-rE8,10
+isa_model-0.3.91.dist-info/RECORD,,