isa-model 0.3.7__py3-none-any.whl → 0.3.9__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.9"
 
 # Main unified client interface
 from isa_model.client import ISAModelClient, create_client

isa_model/client.py

@@ -138,6 +138,7 @@ class ISAModelClient:
         model_hint: Optional[str] = None,
         provider_hint: Optional[str] = None,
         stream: bool = False,
+        tools: Optional[List[Any]] = None,
         **kwargs
     ) -> Union[Dict[str, Any], object]:
         """
@@ -150,6 +151,7 @@ class ISAModelClient:
             model_hint: Optional model preference
             provider_hint: Optional provider preference
             stream: Enable streaming for text services (returns AsyncGenerator)
+            tools: Optional list of tools for function calling (only for text services)
             **kwargs: Additional task-specific parameters
             
         Returns:
@@ -174,6 +176,13 @@ class ISAModelClient:
             async for token in await client.invoke("Hello", "chat", "text", stream=True):
                 print(token, end="", flush=True)
             
+            # Text with tools
+            await client.invoke("What's 5+3?", "chat", "text", tools=[calculator_function])
+            
+            # Streaming with tools
+            async for token in await client.invoke("What's 5+3?", "chat", "text", stream=True, tools=[calculator_function]):
+                print(token, end="")
+            
             # Image generation
             await client.invoke("A beautiful sunset", "generate_image", "image")
             
@@ -193,6 +202,7 @@ class ISAModelClient:
                         service_type=service_type,
                         model_hint=model_hint,
                         provider_hint=provider_hint,
+                        tools=tools,
                         **kwargs
                     )
                 else:
@@ -202,6 +212,7 @@ class ISAModelClient:
                         service_type=service_type,
                         model_hint=model_hint,
                         provider_hint=provider_hint,
+                        tools=tools,
                         **kwargs
                     )
             
@@ -213,6 +224,7 @@ class ISAModelClient:
                     service_type=service_type,
                     model_hint=model_hint,
                     provider_hint=provider_hint,
+                    tools=tools,
                     **kwargs
                 )
             else:
@@ -222,6 +234,7 @@ class ISAModelClient:
                     service_type=service_type,
                     model_hint=model_hint,
                     provider_hint=provider_hint,
+                    tools=tools,
                     **kwargs
                 )
                 
@@ -349,7 +362,8 @@ class ISAModelClient:
         service_type: str,
         model_name: str,
         provider: str,
-        task: str
+        task: str,
+        tools: Optional[List[Any]] = None
     ) -> Any:
         """Get appropriate service instance"""
         
@@ -357,7 +371,11 @@ class ISAModelClient:
         
         # Check cache first
         if cache_key in self._service_cache:
-            return self._service_cache[cache_key]
+            service = self._service_cache[cache_key]
+            # If tools are needed, bind them to the service
+            if tools and service_type == "text":
+                return service.bind_tools(tools)
+            return service
         
         try:
             # Route to appropriate AIFactory method
@@ -387,6 +405,11 @@ class ISAModelClient:
             
             # Cache the service
             self._service_cache[cache_key] = service
+            
+            # If tools are needed, bind them to the service
+            if tools and service_type == "text":
+                return service.bind_tools(tools)
+            
             return service
             
         except Exception as e:
@@ -499,11 +522,20 @@ 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 object (AIMessage or string)
+            return result["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"""
@@ -616,6 +648,7 @@ class ISAModelClient:
         service_type: str,
         model_hint: Optional[str] = None,
         provider_hint: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
         **kwargs
     ) -> Dict[str, Any]:
         """Local invoke using AI Factory (original logic)"""
@@ -634,7 +667,8 @@ class ISAModelClient:
                 service_type=service_type,
                 model_name=selected_model["model_id"],
                 provider=selected_model["provider"],
-                task=task
+                task=task,
+                tools=tools
             )
             
             # Step 3: Execute task with unified interface
@@ -823,6 +857,7 @@ class ISAModelClient:
         service_type: str,
         model_hint: Optional[str] = None,
         provider_hint: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
         **kwargs
     ):
         """Local streaming using AI Factory"""
@@ -840,7 +875,8 @@ class ISAModelClient:
             service_type=service_type,
             model_name=selected_model["model_id"],
             provider=selected_model["provider"],
-            task=task
+            task=task,
+            tools=tools
         )
         
         # Step 3: Yield tokens from the stream

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

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

{isa_model-0.3.7.dist-info → isa_model-0.3.9.dist-info}/RECORD

@@ -1,7 +1,7 @@
-isa_model/__init__.py,sha256=bAbHdrDVQ-mySC_GJtgfLNI8KPcs2LfReBkIOOtpaQQ,867
-isa_model/client.py,sha256=ly4614_LIz5Csg1qG7M-eXtN8VR36ClsMWqsgz111BE,34285
+isa_model/__init__.py,sha256=73ibr8BcJyUmtEj-c86brXCY9BjZPYfnXpMbD1ashwQ,867
+isa_model/client.py,sha256=xJt_wlaCZwv4fG053diFKMVpGCv3Qx0vGyFFPXow9y8,35862
 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
@@ -50,16 +50,6 @@ isa_model/inference/__init__.py,sha256=usfuQJ4zYY2RRtHkE-V6LuJ5aN7WJogtPUj9Qmy4W
 isa_model/inference/ai_factory.py,sha256=oGtRd4wp6IZOTyI3GVKBNN4AtlnrLS7yFZuq2wvkaUg,19784
 isa_model/inference/base.py,sha256=qwOddnSGI0GUdD6qIdGBPQpkW7UjU3Y-zaZvu70B4WA,1278
 isa_model/inference/adapter/unified_api.py,sha256=67_Ok8W20m6Otf6r9WyOEVpnxondP4UAxOASk9ozDk4,8668
-isa_model/inference/providers/__init__.py,sha256=a83q-LMFv8u47wf0XtxvqOw_mlVgA_90wtuwy02qdDE,581
-isa_model/inference/providers/base_provider.py,sha256=PT-YnGwBu-Jn_4T3iAphkAJw_mYmKVLjUID62vf2_Ow,2711
-isa_model/inference/providers/ml_provider.py,sha256=4oGGF7lVWQ91Qh3h7olyPFoACLxCROaMxUZlDiZrRL4,1661
-isa_model/inference/providers/modal_provider.py,sha256=klRYXECD5TJicodHIElsGNGMAsAWRFhvn4yfCRcqdVs,3654
-isa_model/inference/providers/model_cache_manager.py,sha256=dLRpx7OJweQ5LcSAkU7D0DQRfLtIhG6nGvg4W_gau80,15315
-isa_model/inference/providers/ollama_provider.py,sha256=IfM9XhdzfE1faguzS2-4GfhK30v5kDPecD3l4z2eB1w,3620
-isa_model/inference/providers/openai_provider.py,sha256=tB8FMsMivlRx0cfPJ0Yrxh1DCvuXyyjNFXrO4lMkkhA,5366
-isa_model/inference/providers/replicate_provider.py,sha256=0oi_BglIE6-HYgzLau9ifP8OdpAMO-QkwYk0OXRUzPk,4490
-isa_model/inference/providers/triton_provider.py,sha256=GKlth7cTOx6ERbsXXJ0gDNby3kVGQNULBDt098BXBSU,15258
-isa_model/inference/providers/yyds_provider.py,sha256=KbDsopShs11_G9oX3b2i2NgHIqkZV7HYWe9K9uZLccc,4284
 isa_model/inference/services/__init__.py,sha256=yfLz0YGl8ixk6LfTRL6cRTvZMb9F_Pv1QRgGyNc9xYM,386
 isa_model/inference/services/base_service.py,sha256=fVaSx0CogHK71UEsNJeSyM8mhqmq5_9ePbbSZVi3Al8,5085
 isa_model/inference/services/audio/base_stt_service.py,sha256=sfzAfreFdvEOBHtphoTrQSjb-gCoCOW4WCj6iIe51oU,5804
@@ -80,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
@@ -142,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.7.dist-info/METADATA,sha256=yjnMzsQji2XQeqdlohiHFdWkXahAuXr9aQJOd6tOnQ0,12326
-isa_model-0.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isa_model-0.3.7.dist-info/top_level.txt,sha256=eHSy_Xb3kNkh2kK11mi1mZh0Wz91AQ5b8k2KFYO-rE8,10
-isa_model-0.3.7.dist-info/RECORD,,
+isa_model-0.3.9.dist-info/METADATA,sha256=SAC2G5ZmyJ0KvNcE_8ONOGCI53bx691wWFAwb-KQghU,12326
+isa_model-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isa_model-0.3.9.dist-info/top_level.txt,sha256=eHSy_Xb3kNkh2kK11mi1mZh0Wz91AQ5b8k2KFYO-rE8,10
+isa_model-0.3.9.dist-info/RECORD,,

isa_model/inference/providers/__init__.py

@@ -1,19 +0,0 @@
-"""
-Providers - Components for integrating with different model providers
-
-File: isa_model/inference/providers/__init__.py
-This module contains provider implementations for different AI model backends.
-"""
-
-from .base_provider import BaseProvider
-
-__all__ = [
-    "BaseProvider",
-]
-
-# Provider implementations can be imported individually as needed
-# from .triton_provider import TritonProvider
-# from .ollama_provider import OllamaProvider
-# from .yyds_provider import YYDSProvider
-# from .openai_provider import OpenAIProvider
-# from .replicate_provider import ReplicateProvider