isa-model 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

isa_model/core/model_manager.py

@@ -2,7 +2,7 @@ from typing import Dict, Optional, List, Any
 import logging
 from pathlib import Path
 from huggingface_hub import hf_hub_download, snapshot_download
-from huggingface_hub.utils import HfHubHTTPError
+from huggingface_hub.errors import HfHubHTTPError
 from .model_storage import ModelStorage, LocalModelStorage
 from .model_registry import ModelRegistry, ModelType, ModelCapability
 
@@ -11,19 +11,81 @@ logger = logging.getLogger(__name__)
 class ModelManager:
     """Model management service for handling model downloads, versions, and caching"""
     
+    # 统一的模型计费信息 (per 1M tokens)
+    MODEL_PRICING = {
+        # OpenAI Models
+        "openai": {
+            "gpt-4o-mini": {"input": 0.15, "output": 0.6},
+            "gpt-4.1-mini": {"input": 0.4, "output": 1.6},
+            "gpt-4.1-nano": {"input": 0.1, "output": 0.4},
+            "gpt-4o": {"input": 5.0, "output": 15.0},
+            "gpt-4-turbo": {"input": 10.0, "output": 30.0},
+            "gpt-4": {"input": 30.0, "output": 60.0},
+            "gpt-3.5-turbo": {"input": 0.5, "output": 1.5},
+            "text-embedding-3-small": {"input": 0.02, "output": 0.0},
+            "text-embedding-3-large": {"input": 0.13, "output": 0.0},
+            "whisper-1": {"input": 6.0, "output": 0.0},
+            "tts-1": {"input": 15.0, "output": 0.0},
+            "tts-1-hd": {"input": 30.0, "output": 0.0},
+        },
+        # Ollama Models (免费本地模型)
+        "ollama": {
+            "llama3.2:3b-instruct-fp16": {"input": 0.0, "output": 0.0},
+            "llama3.2-vision:latest": {"input": 0.0, "output": 0.0},
+            "bge-m3": {"input": 0.0, "output": 0.0},
+        },
+        # Replicate Models
+        "replicate": {
+            "black-forest-labs/flux-schnell": {"input": 3.0, "output": 0.0},  # $3 per 1000 images
+            "black-forest-labs/flux-kontext-pro": {"input": 40.0, "output": 0.0},  # $0.04 per image = $40 per 1000 images
+            "meta/meta-llama-3-8b-instruct": {"input": 0.05, "output": 0.25},
+            "kokoro-82m": {"input": 0.0, "output": 0.4},  # ~$0.0004 per second
+            "jaaari/kokoro-82m:f559560eb822dc509045f3921a1921234918b91739db4bf3daab2169b71c7a13": {"input": 0.0, "output": 0.4},
+        }
+    }
+    
     def __init__(self, 
                  storage: Optional[ModelStorage] = None,
                  registry: Optional[ModelRegistry] = None):
         self.storage = storage or LocalModelStorage()
         self.registry = registry or ModelRegistry()
     
+    def get_model_pricing(self, provider: str, model_name: str) -> Dict[str, float]:
+        """获取模型定价信息"""
+        return self.MODEL_PRICING.get(provider, {}).get(model_name, {"input": 0.0, "output": 0.0})
+    
+    def calculate_cost(self, provider: str, model_name: str, input_tokens: int, output_tokens: int) -> float:
+        """计算请求成本"""
+        pricing = self.get_model_pricing(provider, model_name)
+        input_cost = (input_tokens / 1_000_000) * pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * pricing["output"]
+        return input_cost + output_cost
+    
+    def get_cheapest_model(self, provider: str, model_type: str = "llm") -> Optional[str]:
+        """获取最便宜的模型"""
+        provider_models = self.MODEL_PRICING.get(provider, {})
+        if not provider_models:
+            return None
+        
+        # 计算每个模型的平均成本 (假设输入输出比例 1:1)
+        cheapest_model = None
+        lowest_cost = float('inf')
+        
+        for model_name, pricing in provider_models.items():
+            avg_cost = (pricing["input"] + pricing["output"]) / 2
+            if avg_cost < lowest_cost:
+                lowest_cost = avg_cost
+                cheapest_model = model_name
+        
+        return cheapest_model
+
     async def get_model(self, 
                        model_id: str, 
                        repo_id: str,
                        model_type: ModelType,
                        capabilities: List[ModelCapability],
                        revision: Optional[str] = None,
-                       force_download: bool = False) -> Path:
+                       force_download: bool = False) -> Optional[Path]:
         """
         Get model files, downloading if necessary
         
@@ -36,7 +98,7 @@ class ModelManager:
             force_download: Force re-download even if cached
             
         Returns:
-            Path to the model files
+            Path to the model files or None if failed
         """
         # Check if model is already downloaded
         if not force_download:
@@ -80,7 +142,10 @@ class ModelManager:
             
         except HfHubHTTPError as e:
             logger.error(f"Failed to download model {model_id}: {e}")
-            raise
+            return None
+        except Exception as e:
+            logger.error(f"Unexpected error downloading model {model_id}: {e}")
+            return None
     
     async def list_models(self) -> List[Dict[str, Any]]:
         """List all downloaded models with their metadata"""

isa_model/inference/ai_factory.py

@@ -3,21 +3,27 @@
 
 """
 Simplified AI Factory for creating inference services
-Uses the new service architecture with proper base classes
+Uses the new service architecture with proper base classes and centralized API key management
 """
 
-from typing import Dict, Type, Any, Optional, Tuple, List
+from typing import Dict, Type, Any, Optional, Tuple, List, TYPE_CHECKING, cast
 import logging
-import os
 from isa_model.inference.providers.base_provider import BaseProvider
 from isa_model.inference.services.base_service import BaseService
 from isa_model.inference.base import ModelType
+from isa_model.inference.services.vision.base_vision_service import BaseVisionService
+from isa_model.inference.services.vision.base_image_gen_service import BaseImageGenService
+
+if TYPE_CHECKING:
+    from isa_model.inference.services.audio.base_stt_service import BaseSTTService
+    from isa_model.inference.services.audio.base_tts_service import BaseTTSService
 
 logger = logging.getLogger(__name__)
 
 class AIFactory:
     """
     Simplified Factory for creating AI services with proper inheritance hierarchy
+    API key management is handled by individual providers
     """
     
     _instance = None
@@ -49,7 +55,7 @@ class AIFactory:
             # Register Replicate services
             self._register_replicate_services()
             
-            logger.info("AI Factory initialized with simplified service architecture")
+            logger.info("AI Factory initialized with centralized provider API key management")
             
         except Exception as e:
             logger.error(f"Error initializing services: {e}")
@@ -79,10 +85,15 @@ class AIFactory:
             from isa_model.inference.providers.openai_provider import OpenAIProvider
             from isa_model.inference.services.llm.openai_llm_service import OpenAILLMService
             from isa_model.inference.services.audio.openai_tts_service import OpenAITTSService
+            from isa_model.inference.services.audio.openai_stt_service import OpenAISTTService
+            from isa_model.inference.services.embedding.openai_embed_service import OpenAIEmbedService
+            from isa_model.inference.services.vision.openai_vision_service import OpenAIVisionService
             
             self.register_provider('openai', OpenAIProvider)
             self.register_service('openai', ModelType.LLM, OpenAILLMService)
             self.register_service('openai', ModelType.AUDIO, OpenAITTSService)
+            self.register_service('openai', ModelType.EMBEDDING, OpenAIEmbedService)
+            self.register_service('openai', ModelType.VISION, OpenAIVisionService)
             
             logger.info("OpenAI services registered successfully")
             
@@ -94,9 +105,11 @@ class AIFactory:
         try:
             from isa_model.inference.providers.replicate_provider import ReplicateProvider
             from isa_model.inference.services.vision.replicate_image_gen_service import ReplicateImageGenService
+            from isa_model.inference.services.audio.replicate_tts_service import ReplicateTTSService
             
             self.register_provider('replicate', ReplicateProvider)
             self.register_service('replicate', ModelType.VISION, ReplicateImageGenService)
+            self.register_service('replicate', ModelType.AUDIO, ReplicateTTSService)
             
             logger.info("Replicate services registered successfully")
             
@@ -114,7 +127,7 @@ class AIFactory:
     
     def create_service(self, provider_name: str, model_type: ModelType, 
                       model_name: str, config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Create a service instance"""
+        """Create a service instance with provider-managed configuration"""
         try:
             cache_key = f"{provider_name}_{model_type}_{model_name}"
             
@@ -133,8 +146,8 @@ class AIFactory:
                     f"No service registered for provider '{provider_name}' and model type '{model_type}'"
                 )
             
-            # Create provider and service
-            provider = provider_class(config=config or {})
+            # Create provider with user config (provider handles .env loading)
+            provider = provider_class(config=config)
             service = service_class(provider=provider, model_name=model_name)
             
             self._cached_services[cache_key] = service
@@ -144,81 +157,254 @@ class AIFactory:
             logger.error(f"Error creating service: {e}")
             raise
     
-    # Convenient methods for common services
-    def get_llm_service(self, model_name: str = "llama3.1", provider: str = "ollama",
+    # Convenient methods for common services with updated defaults
+    def get_llm_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
                        config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get a LLM service instance
+        Get a LLM service instance with automatic defaults
         
         Args:
-            model_name: Name of the model to use
-            provider: Provider name ('ollama', 'openai')
-            config: Optional configuration dictionary
+            model_name: Name of the model to use (defaults: OpenAI="gpt-4.1-nano", Ollama="llama3.2:3b")
+            provider: Provider name (defaults to 'openai' for production, 'ollama' for dev)
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+                   Can include: streaming=True/False, temperature, max_tokens, etc.
             
         Returns:
             LLM service instance
         """
-        return self.create_service(provider, ModelType.LLM, model_name, config)
+        # Set defaults based on provider
+        if provider == "openai":
+            final_model_name = model_name or "gpt-4.1-nano"
+            final_provider = provider
+        elif provider == "ollama":
+            final_model_name = model_name or "llama3.2:3b-instruct-fp16"
+            final_provider = provider
+        else:
+            # Default provider selection - OpenAI with cheapest model
+            final_provider = provider or "openai"
+            if final_provider == "openai":
+                final_model_name = model_name or "gpt-4.1-nano"
+            else:
+                final_model_name = model_name or "llama3.2:3b-instruct-fp16"
+        
+        return self.create_service(final_provider, ModelType.LLM, final_model_name, config)
     
-    def get_embedding_service(self, model_name: str = "bge-m3", provider: str = "ollama",
+    def get_embedding_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
                              config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get an embedding service instance
+        Get an embedding service instance with automatic defaults
         
         Args:
-            model_name: Name of the model to use
-            provider: Provider name ('ollama')
-            config: Optional configuration dictionary
+            model_name: Name of the model to use (defaults: OpenAI="text-embedding-3-small", Ollama="bge-m3")
+            provider: Provider name (defaults to 'openai' for production, 'ollama' for dev)
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
             
         Returns:
             Embedding service instance
         """
-        return self.create_service(provider, ModelType.EMBEDDING, model_name, config)
+        # Set defaults based on provider
+        if provider == "openai":
+            final_model_name = model_name or "text-embedding-3-small"
+            final_provider = provider
+        elif provider == "ollama":
+            final_model_name = model_name or "bge-m3"
+            final_provider = provider
+        else:
+            # Default provider selection
+            final_provider = provider or "openai"
+            if final_provider == "openai":
+                final_model_name = model_name or "text-embedding-3-small"
+            else:
+                final_model_name = model_name or "bge-m3"
+        
+        return self.create_service(final_provider, ModelType.EMBEDDING, final_model_name, config)
     
-    def get_vision_service(self, model_name: str, provider: str,
-                          config: Optional[Dict[str, Any]] = None) -> BaseService:
+    def get_vision_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                          config: Optional[Dict[str, Any]] = None) -> BaseVisionService:
         """
-        Get a vision service instance
+        Get a vision service instance with automatic defaults
         
         Args:
-            model_name: Name of the model to use
-            provider: Provider name ('ollama', 'replicate')
-            config: Optional configuration dictionary
+            model_name: Name of the model to use (defaults: OpenAI="gpt-4.1-mini", Ollama="gemma3:4b")
+            provider: Provider name (defaults to 'openai' for production, 'ollama' for dev)
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
             
         Returns:
             Vision service instance
         """
-        return self.create_service(provider, ModelType.VISION, model_name, config)
+        # Set defaults based on provider
+        if provider == "openai":
+            final_model_name = model_name or "gpt-4.1-mini"
+            final_provider = provider
+        elif provider == "ollama":
+            final_model_name = model_name or "llama3.2-vision:latest"
+            final_provider = provider
+        else:
+            # Default provider selection
+            final_provider = provider or "openai"
+            if final_provider == "openai":
+                final_model_name = model_name or "gpt-4.1-mini"
+            else:
+                final_model_name = model_name or "llama3.2-vision:latest"
+        
+        return cast(BaseVisionService, self.create_service(final_provider, ModelType.VISION, final_model_name, config))
+    
+    def get_image_generation_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                                   config: Optional[Dict[str, Any]] = None) -> 'BaseImageGenService':
+        """
+        Get an image generation service instance with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: "black-forest-labs/flux-schnell" for production)
+            provider: Provider name (defaults to 'replicate')
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+            
+        Returns:
+            Image generation service instance
+        """
+        # Set defaults based on provider
+        final_provider = provider or "replicate"
+        if final_provider == "replicate":
+            final_model_name = model_name or "black-forest-labs/flux-schnell"
+        else:
+            final_model_name = model_name or "black-forest-labs/flux-schnell"
+        
+        return cast('BaseImageGenService', self.create_service(final_provider, ModelType.VISION, final_model_name, config))
     
-    def get_image_generation_service(self, model_name: str, provider: str = "replicate",
-                                   config: Optional[Dict[str, Any]] = None) -> BaseService:
+    def get_img(self, type: str = "t2i", model_name: Optional[str] = None, provider: Optional[str] = None,
+                config: Optional[Dict[str, Any]] = None) -> 'BaseImageGenService':
         """
-        Get an image generation service instance
+        Get an image generation service with type-specific defaults
         
         Args:
-            model_name: Name of the model to use (e.g., "stability-ai/sdxl")
-            provider: Provider name ('replicate')
+            type: Image generation type:
+                  - "t2i" (text-to-image): Uses flux-schnell ($3 per 1000 images)
+                  - "i2i" (image-to-image): Uses flux-kontext-pro ($0.04 per image)
+            model_name: Optional model name override
+            provider: Provider name (defaults to 'replicate')
             config: Optional configuration dictionary
             
         Returns:
             Image generation service instance
+            
+        Usage:
+            # Text-to-image (default)
+            img_service = AIFactory().get_img()
+            img_service = AIFactory().get_img(type="t2i")
+            
+            # Image-to-image
+            img_service = AIFactory().get_img(type="i2i")
+            
+            # Custom model
+            img_service = AIFactory().get_img(type="t2i", model_name="custom-model")
         """
-        return self.create_service(provider, ModelType.VISION, model_name, config)
+        # Set defaults based on type
+        final_provider = provider or "replicate"
+        
+        if type == "t2i":
+            # Text-to-image: flux-schnell
+            final_model_name = model_name or "black-forest-labs/flux-schnell"
+        elif type == "i2i":
+            # Image-to-image: flux-kontext-pro
+            final_model_name = model_name or "black-forest-labs/flux-kontext-pro"
+        else:
+            raise ValueError(f"Unknown image generation type: {type}. Use 't2i' or 'i2i'")
+        
+        return cast('BaseImageGenService', self.create_service(final_provider, ModelType.VISION, final_model_name, config))
     
-    def get_audio_service(self, model_name: str = "tts-1", provider: str = "openai",
+    def get_audio_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
                          config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get an audio service instance
+        Get an audio service instance (TTS) with automatic defaults
         
         Args:
-            model_name: Name of the model to use
-            provider: Provider name ('openai')
-            config: Optional configuration dictionary
+            model_name: Name of the model to use (defaults: OpenAI="tts-1")
+            provider: Provider name (defaults to 'openai')
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
             
         Returns:
             Audio service instance
         """
-        return self.create_service(provider, ModelType.AUDIO, model_name, config)
+        # Set defaults based on provider
+        final_provider = provider or "openai"
+        if final_provider == "openai":
+            final_model_name = model_name or "tts-1"
+        else:
+            final_model_name = model_name or "tts-1"
+        
+        return self.create_service(final_provider, ModelType.AUDIO, final_model_name, config)
+    
+    def get_tts_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                       config: Optional[Dict[str, Any]] = None) -> 'BaseTTSService':
+        """
+        Get a Text-to-Speech service instance with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: Replicate="kokoro-82m", OpenAI="tts-1")
+            provider: Provider name (defaults to 'replicate' for production, 'openai' for dev)
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+            
+        Returns:
+            TTS service instance
+        """
+        # Set defaults based on provider
+        if provider == "replicate":
+            model_name = model_name or "kokoro-82m"
+        elif provider == "openai":
+            model_name = model_name or "tts-1"
+        else:
+            # Default provider selection
+            provider = provider or "replicate"
+            if provider == "replicate":
+                model_name = model_name or "kokoro-82m"
+            else:
+                model_name = model_name or "tts-1"
+        
+        # Ensure model_name is never None
+        if model_name is None:
+            model_name = "tts-1"
+        
+        if provider == "replicate":
+            from isa_model.inference.services.audio.replicate_tts_service import ReplicateTTSService
+            from isa_model.inference.providers.replicate_provider import ReplicateProvider
+            
+            # Use full model name for Replicate
+            if model_name == "kokoro-82m":
+                model_name = "jaaari/kokoro-82m:f559560eb822dc509045f3921a1921234918b91739db4bf3daab2169b71c7a13"
+            
+            provider_instance = ReplicateProvider(config=config)
+            return ReplicateTTSService(provider=provider_instance, model_name=model_name)
+        else:
+            return cast('BaseTTSService', self.get_audio_service(model_name, provider, config))
+    
+    def get_stt_service(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                       config: Optional[Dict[str, Any]] = None) -> 'BaseSTTService':
+        """
+        Get a Speech-to-Text service instance with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: "whisper-1")
+            provider: Provider name (defaults to 'openai')
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+            
+        Returns:
+            STT service instance
+        """
+        # Set defaults based on provider
+        provider = provider or "openai"
+        if provider == "openai":
+            model_name = model_name or "whisper-1"
+        
+        # Ensure model_name is never None
+        if model_name is None:
+            model_name = "whisper-1"
+        
+        from isa_model.inference.services.audio.openai_stt_service import OpenAISTTService
+        from isa_model.inference.providers.openai_provider import OpenAIProvider
+        
+        # Create provider and service directly with config
+        provider_instance = OpenAIProvider(config=config)
+        return OpenAISTTService(provider=provider_instance, model_name=model_name)
     
     def get_available_services(self) -> Dict[str, List[str]]:
         """Get information about available services"""
@@ -241,16 +427,90 @@ class AIFactory:
             cls._instance = cls()
         return cls._instance
     
-    # Alias methods for backward compatibility with tests
-    def get_llm(self, model_name: str = "llama3.1", provider: str = "ollama",
+    # Alias method for cleaner API
+    def get_llm(self, model_name: Optional[str] = None, provider: Optional[str] = None,
                 config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Alias for get_llm_service"""
+        """
+        Alias for get_llm_service with cleaner naming
+        
+        Usage:
+            llm = AIFactory().get_llm()  # Uses gpt-4.1-nano by default
+            llm = AIFactory().get_llm(model_name="llama3.2", provider="ollama")
+            llm = AIFactory().get_llm(model_name="gpt-4.1-mini", provider="openai", config={"streaming": True})
+        """
         return self.get_llm_service(model_name, provider, config)
     
-    def get_embedding(self, model_name: str = "bge-m3", provider: str = "ollama",
-                     config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Alias for get_embedding_service"""
+    def get_embed(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                     config: Optional[Dict[str, Any]] = None) -> 'BaseEmbedService':
+        """
+        Get embedding service with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: OpenAI="text-embedding-3-small", Ollama="bge-m3")
+            provider: Provider name (defaults to 'openai' for production)
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+            
+        Returns:
+            Embedding service instance
+            
+        Usage:
+            # Default (OpenAI text-embedding-3-small)
+            embed = AIFactory().get_embed()
+            
+            # Custom model
+            embed = AIFactory().get_embed(model_name="text-embedding-3-large", provider="openai")
+            
+            # Development (Ollama)
+            embed = AIFactory().get_embed(provider="ollama")
+        """
         return self.get_embedding_service(model_name, provider, config)
+
+    def get_stt(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                config: Optional[Dict[str, Any]] = None) -> 'BaseSTTService':
+        """
+        Get Speech-to-Text service with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: "whisper-1")
+            provider: Provider name (defaults to 'openai')
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+            
+        Returns:
+            STT service instance
+            
+        Usage:
+            # Default (OpenAI whisper-1)
+            stt = AIFactory().get_stt()
+            
+            # Custom configuration
+            stt = AIFactory().get_stt(model_name="whisper-1", provider="openai")
+        """
+        return self.get_stt_service(model_name, provider, config)
+
+    def get_tts(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                config: Optional[Dict[str, Any]] = None) -> 'BaseTTSService':
+        """
+        Get Text-to-Speech service with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: Replicate="kokoro-82m", OpenAI="tts-1")
+            provider: Provider name (defaults to 'replicate' for production, 'openai' for dev)
+            config: Optional configuration dictionary (auto-loads from .env if not provided)
+            
+        Returns:
+            TTS service instance
+            
+        Usage:
+            # Default (Replicate kokoro-82m)
+            tts = AIFactory().get_tts()
+            
+            # Development (OpenAI tts-1)
+            tts = AIFactory().get_tts(provider="openai")
+            
+            # Custom model
+            tts = AIFactory().get_tts(model_name="tts-1-hd", provider="openai")
+        """
+        return self.get_tts_service(model_name, provider, config)
     
     def get_vision_model(self, model_name: str, provider: str,
                         config: Optional[Dict[str, Any]] = None) -> BaseService:
@@ -258,4 +518,33 @@ class AIFactory:
         if provider == "replicate":
             return self.get_image_generation_service(model_name, provider, config)
         else:
-            return self.get_vision_service(model_name, provider, config) 
+            return self.get_vision_service(model_name, provider, config)
+    
+    def get_vision(
+        self,
+        model_name: Optional[str] = None,
+        provider: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None
+    ) -> 'BaseVisionService':
+        """
+        Get vision service with automatic defaults
+        
+        Args:
+            model_name: Model name (default: gpt-4.1-nano)
+            provider: Provider name (default: openai)
+            config: Optional configuration override
+            
+        Returns:
+            Vision service instance
+        """
+        # Set defaults
+        if provider is None:
+            provider = "openai"
+        if model_name is None:
+            model_name = "gpt-4.1-nano"
+        
+        return self.get_vision_service(
+            model_name=model_name,
+            provider=provider,
+            config=config
+        )