isa-model 0.4.0__py3-none-any.whl → 0.4.4__py3-none-any.whl

isa_model/inference/services/llm/openai_llm_service.py

@@ -20,6 +20,8 @@ class OpenAILLMService(BaseLLMService):
         
         # Check if this is an O-series reasoning model
         self.is_reasoning_model = model_name.startswith("o4-") or model_name.startswith("o3-")
+        self.uses_completion_tokens = self.is_reasoning_model or model_name.startswith("gpt-5")
+        self.requires_default_temperature = self.is_reasoning_model or model_name.startswith("gpt-5")
         self.supports_deep_research = "deep-search" in model_name or "deep-research" in model_name
         
         # Get configuration from centralized config manager
@@ -36,7 +38,9 @@ class OpenAILLMService(BaseLLMService):
             self.client = AsyncOpenAI(
                 api_key=provider_config["api_key"],
                 base_url=provider_config.get("api_base_url", "https://api.openai.com/v1"),
-                organization=provider_config.get("organization")
+                organization=provider_config.get("organization"),
+                timeout=10.0,  # 10 second timeout for first token (much faster than 600s default)
+                max_retries=2  # Retry on timeout
             )
             
             logger.info(f"Initialized OpenAILLMService with model {self.model_name} and endpoint {self.client.base_url}")
@@ -70,6 +74,8 @@ class OpenAILLMService(BaseLLMService):
         
         # Copy OpenAI-specific attributes
         bound_service.is_reasoning_model = self.is_reasoning_model
+        bound_service.uses_completion_tokens = self.uses_completion_tokens
+        bound_service.requires_default_temperature = self.requires_default_temperature
         bound_service.supports_deep_research = self.supports_deep_research
         
         # Copy base class attributes
@@ -103,7 +109,7 @@ class OpenAILLMService(BaseLLMService):
         
         return bound_service
     
-    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
+    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False, **extra_kwargs) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
         """
         True streaming method - yields tokens one by one as they arrive
         
@@ -121,19 +127,19 @@ class OpenAILLMService(BaseLLMService):
             if use_responses_api:
                 logger.info(f"Using Responses API streaming for {self.model_name}")
                 # Use Responses API streaming
-                async for chunk in self._astream_responses_api(input_data, show_reasoning):
+                async for chunk in self._astream_responses_api(input_data, show_reasoning, **extra_kwargs):
                     yield chunk
             else:
                 logger.debug(f"Using Chat Completions API streaming for {self.model_name}")
                 # Use Chat Completions API streaming
-                async for chunk in self._astream_chat_completions_api(input_data):
+                async for chunk in self._astream_chat_completions_api(input_data, **extra_kwargs):
                     yield chunk
                     
         except Exception as e:
             logger.error(f"Error in astream: {e}")
             raise
     
-    async def _astream_responses_api(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
+    async def _astream_responses_api(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False, **extra_kwargs) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
         """Stream using Responses API for reasoning models and deep research models"""
         try:
             # Use adapter manager to prepare messages
@@ -228,7 +234,7 @@ class OpenAILLMService(BaseLLMService):
             logger.error(f"Error in _astream_responses_api: {e}")
             raise
     
-    async def _astream_chat_completions_api(self, input_data: Union[str, List[Dict[str, str]], Any]) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
+    async def _astream_chat_completions_api(self, input_data: Union[str, List[Dict[str, str]], Any], **extra_kwargs) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
         """Stream using Chat Completions API for standard models"""
         try:
             # Use adapter manager to prepare messages
@@ -242,13 +248,13 @@ class OpenAILLMService(BaseLLMService):
                 "stream": True
             }
             
-            # O4 models only support temperature=1 (default)
-            if not self.is_reasoning_model:
+            # O4 and GPT-5 models only support temperature=1 (default)
+            if not self.requires_default_temperature:
                 kwargs["temperature"] = provider_config.get("temperature", 0.7)
             
-            # O4 models use max_completion_tokens instead of max_tokens
+            # O4 and GPT-5 models use max_completion_tokens instead of max_tokens
             max_tokens_value = provider_config.get("max_tokens", 1024)
-            if self.is_reasoning_model:
+            if self.uses_completion_tokens:
                 kwargs["max_completion_tokens"] = max_tokens_value
             else:
                 kwargs["max_tokens"] = max_tokens_value
@@ -259,6 +265,11 @@ class OpenAILLMService(BaseLLMService):
                 kwargs["tools"] = tool_schemas
                 kwargs["tool_choice"] = "auto"
             
+            # Add response_format if specified (for JSON mode)
+            if 'response_format' in extra_kwargs:
+                kwargs['response_format'] = extra_kwargs['response_format']
+                logger.debug(f"Using response_format in streaming: {extra_kwargs['response_format']}")
+            
             # Stream tokens and detect tool calls
             content_chunks = []
             tool_calls_accumulator = {}  # Track complete tool calls by ID
@@ -360,13 +371,14 @@ class OpenAILLMService(BaseLLMService):
             logger.error(f"Error in _astream_chat_completions_api: {e}")
             raise
     
-    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False) -> Union[str, Any]:
+    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False, **extra_kwargs) -> Union[str, Any]:
         """
         Unified invoke method for all input types
         
         Args:
             input_data: Input messages or text
             show_reasoning: If True and model supports it, show reasoning process using Responses API
+            **extra_kwargs: Additional parameters to pass to the API (e.g., response_format)
         """
         try:
             # Use adapter manager to prepare messages
@@ -385,13 +397,13 @@ class OpenAILLMService(BaseLLMService):
                 "messages": messages
             }
             
-            # O4 models only support temperature=1 (default)
-            if not self.is_reasoning_model:
+            # O4 and GPT-5 models only support temperature=1 (default)
+            if not self.requires_default_temperature:
                 kwargs["temperature"] = provider_config.get("temperature", 0.7)
             
-            # O4 models use max_completion_tokens instead of max_tokens
+            # O4 and GPT-5 models use max_completion_tokens instead of max_tokens
             max_tokens_value = provider_config.get("max_tokens", 1024)
-            if self.is_reasoning_model:
+            if self.uses_completion_tokens:
                 kwargs["max_completion_tokens"] = max_tokens_value
             else:
                 kwargs["max_tokens"] = max_tokens_value
@@ -403,11 +415,16 @@ class OpenAILLMService(BaseLLMService):
                 if not use_responses_api:  # Responses API handles tool choice differently
                     kwargs["tool_choice"] = "auto"
             
+            # Add response_format if specified (for JSON mode)
+            if 'response_format' in extra_kwargs:
+                kwargs['response_format'] = extra_kwargs['response_format']
+                logger.debug(f"Using response_format: {extra_kwargs['response_format']}")
+            
             # Handle streaming vs non-streaming
             if self.streaming:
                 # TRUE STREAMING MODE - collect all chunks from the stream
                 content_chunks = []
-                async for token in self.astream(input_data, show_reasoning=show_reasoning):
+                async for token in self.astream(input_data, show_reasoning=show_reasoning, **extra_kwargs):
                     if isinstance(token, str):
                         content_chunks.append(token)
                     elif isinstance(token, dict) and "result" in token:

isa_model/inference/services/llm/yyds_llm_service.py

@@ -63,16 +63,19 @@ class YydsLLMService(BaseLLMService):
         
         return bound_service
     
-    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any]) -> AsyncGenerator[str, None]:
+    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any], **kwargs) -> AsyncGenerator[str, None]:
         """
         True streaming method - yields tokens one by one as they arrive
         
         Args:
             input_data: Same as ainvoke
+            **kwargs: Additional parameters (will filter out unsupported ones)
             
         Yields:
             Individual tokens as they arrive from the API
         """
+        # Remove parameters that yyds doesn't support
+        kwargs.pop('show_reasoning', None)  # OpenAI-specific parameter
         try:
             # Use adapter manager to prepare messages
             messages = self._prepare_messages(input_data)
@@ -115,8 +118,11 @@ class YydsLLMService(BaseLLMService):
             logger.error(f"Error in astream: {e}")
             raise
     
-    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any]) -> Union[str, Any]:
+    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any], **kwargs) -> Union[str, Any]:
         """Unified invoke method for all input types"""
+        # Remove parameters that yyds doesn't support
+        kwargs.pop('show_reasoning', None)  # OpenAI-specific parameter
+        kwargs.pop('task', None)  # Handled internally
         try:
             # Use adapter manager to prepare messages
             messages = self._prepare_messages(input_data)

isa_model/inference/services/vision/__init__.py

@@ -31,6 +31,21 @@ except ImportError:
     OllamaVisionService = None
     OLLAMA_VISION_AVAILABLE = False
 
+# Computer Vision specialized services
+try:
+    from .vgg16_vision_service import VGG16VisionService
+    VGG16_VISION_AVAILABLE = True
+except ImportError:
+    VGG16VisionService = None
+    VGG16_VISION_AVAILABLE = False
+
+try:
+    from .blip_vision_service import BLIPVisionService
+    BLIP_VISION_AVAILABLE = True
+except ImportError:
+    BLIPVisionService = None
+    BLIP_VISION_AVAILABLE = False
+
 __all__ = [
     "BaseVisionService",
     "OpenAIVisionService", 
@@ -43,4 +58,10 @@ if ISA_VISION_AVAILABLE:
     __all__.append("ISAVisionService")
 
 if OLLAMA_VISION_AVAILABLE:
-    __all__.append("OllamaVisionService") 
+    __all__.append("OllamaVisionService")
+
+if VGG16_VISION_AVAILABLE:
+    __all__.append("VGG16VisionService")
+
+if BLIP_VISION_AVAILABLE:
+    __all__.append("BLIPVisionService") 

isa_model/inference/services/vision/helpers/image_utils.py

@@ -59,25 +59,28 @@ def get_image_data(image: Union[str, BinaryIO]) -> bytes:
 
 def compress_image(image_data: Union[bytes, BytesIO], max_size: int = 1024) -> bytes:
     """压缩图片以减小大小
-    
+
     Args:
         image_data: 图片数据，可以是 bytes 或 BytesIO
         max_size: 最大尺寸（像素）
-        
+
     Returns:
         bytes: 压缩后的图片数据
     """
     try:
+        # Ensure max_size is int (type safety)
+        max_size = int(max_size)
+
         # 如果输入是 bytes，转换为 BytesIO
         if isinstance(image_data, bytes):
             image_data = BytesIO(image_data)
-            
+
         img = Image.open(image_data)
-        
+
         # 转换为 RGB 模式（如果需要）
         if img.mode in ('RGBA', 'P'):
             img = img.convert('RGB')
-        
+
         # 计算新尺寸，保持宽高比
         ratio = max_size / max(img.size)
         if ratio < 1:

isa_model/inference/services/vision/isa_vision_service.py

@@ -9,6 +9,7 @@ import logging
 import base64
 import io
 import time
+import asyncio
 from typing import Dict, Any, List, Union, Optional, BinaryIO
 from PIL import Image
 
@@ -36,7 +37,7 @@ class ISAVisionService(BaseVisionService):
     def __init__(self, 
                  modal_app_id: str = "ap-VlHUQoiPUdy9cgrHSfG7Fk",
                  modal_app_name: str = "isa-vision-ui-optimized",
-                 timeout: int = 30):
+                 timeout: int = 60):
         """
         初始化ISA Vision服务
         
@@ -77,6 +78,31 @@ class ISAVisionService(BaseVisionService):
         self.request_count = 0
         self.total_cost = 0.0
         
+        # 性能优化 - 预热连接（延迟初始化）
+        self._connection_warmed = False
+        
+        # 简单缓存机制（可选）
+        self._result_cache = {}
+        self._cache_max_size = 100
+        
+    async def _warm_connection(self):
+        """预热Modal连接，减少首次调用延迟"""
+        if self._connection_warmed or not self.modal_app:
+            return
+            
+        try:
+            logger.info("Warming up Modal connection...")
+            # 尝试获取服务状态来预热连接
+            if hasattr(self.modal_app, 'list_functions'):
+                await asyncio.wait_for(
+                    asyncio.to_thread(self.modal_app.list_functions),
+                    timeout=10
+                )
+            self._connection_warmed = True
+            logger.info("✅ Modal connection warmed up")
+        except Exception as e:
+            logger.warning(f"Failed to warm up connection: {e}")
+    
     async def analyze_image(
         self, 
         image: Union[str, BinaryIO],
@@ -154,6 +180,9 @@ class ISAVisionService(BaseVisionService):
                     'error': 'Modal app or service not available'
                 }
             
+            # 预热连接以减少延迟
+            await self._warm_connection()
+            
             # 准备图像数据
             image_b64 = await self._prepare_image_base64(image)
             
@@ -208,11 +237,22 @@ class ISAVisionService(BaseVisionService):
             
             # 创建实例并调用优化方法（快速模式，无字幕）
             instance = OptimizedUIDetectionService()
-            result = instance.detect_ui_elements_fast.remote(image_b64, enable_captions=False)
+            # 使用超时控制Modal调用
+            result = await asyncio.wait_for(
+                instance.detect_ui_elements_fast.remote(image_b64, enable_captions=False),
+                timeout=self.timeout
+            )
             
             logger.info("✅ Modal SDK call successful")
             return result
                         
+        except asyncio.TimeoutError:
+            logger.error(f"Modal SDK call timed out after {self.timeout} seconds")
+            return {
+                'success': False,
+                'error': f'Modal service timeout after {self.timeout} seconds',
+                'timeout': True
+            }
         except Exception as e:
             logger.error(f"Modal SDK call failed: {e}")
             return {
@@ -316,11 +356,22 @@ class ISAVisionService(BaseVisionService):
             
             # 创建实例并调用方法
             instance = SuryaOCRService()
-            result = instance.extract_text.remote(image_b64, languages)
+            # 使用超时控制OCR调用
+            result = await asyncio.wait_for(
+                instance.extract_text.remote(image_b64, languages),
+                timeout=self.timeout
+            )
             
             logger.info("✅ OCR service call successful")
             return result
                         
+        except asyncio.TimeoutError:
+            logger.error(f"OCR service call timed out after {self.timeout} seconds")
+            return {
+                'success': False,
+                'error': f'OCR service timeout after {self.timeout} seconds',
+                'timeout': True
+            }
         except Exception as e:
             logger.error(f"OCR service call failed: {e}")
             return {
@@ -499,7 +550,7 @@ class ISAVisionService(BaseVisionService):
         """准备base64编码的图像"""
         if isinstance(image, str):
             # Check if it's already base64 encoded
-            if image.startswith('data:image') or len(image) > 1000:
+            if image.startswith('data:image') or (not image.startswith('http') and len(image) > 1000):
                 # Likely already base64
                 if image.startswith('data:image'):
                     # Extract base64 part
@@ -507,6 +558,16 @@ class ISAVisionService(BaseVisionService):
                 else:
                     # Assume it's pure base64
                     return image
+            elif image.startswith('http://') or image.startswith('https://'):
+                # URL - download the image
+                import aiohttp
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(image) as response:
+                        if response.status == 200:
+                            image_data = await response.read()
+                            return base64.b64encode(image_data).decode('utf-8')
+                        else:
+                            raise ValueError(f"Failed to download image from URL: {response.status}")
             else:
                 # File path
                 with open(image, 'rb') as f:

isa_model/inference/services/vision/openai_vision_service.py

@@ -92,12 +92,21 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
                 }
             ]
             
-            response = await self._client.chat.completions.create(  # type: ignore
-                model=self.model_name,
-                messages=messages,  # type: ignore
-                max_tokens=max_tokens,
-                temperature=self.temperature
-            )
+            # Use max_completion_tokens for newer models like gpt-4o-mini
+            completion_params = {
+                "model": self.model_name,
+                "messages": messages,  # type: ignore
+                "temperature": self.temperature
+            }
+            
+            # Check if model uses new parameter name
+            # All newer models (gpt-4o, gpt-4.1, o1, etc.) use max_completion_tokens
+            if any(prefix in self.model_name for prefix in ["gpt-4o", "gpt-4.1", "o1"]):
+                completion_params["max_completion_tokens"] = max_tokens
+            else:
+                completion_params["max_tokens"] = max_tokens
+            
+            response = await self._client.chat.completions.create(**completion_params)  # type: ignore
             
             # Track usage for billing
             if response.usage:
@@ -162,7 +171,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         图像描述 - 使用专门提示词
         """
         prompt = self.get_task_prompt("describe", detail_level=detail_level)
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def extract_text(self, image: Union[str, BinaryIO]) -> Dict[str, Any]:
         """
@@ -170,7 +179,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         """
         prompt = self.get_task_prompt("extract_text")
         
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def detect_objects(
         self, 
@@ -182,7 +191,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         """
         prompt = self.get_task_prompt("detect_objects", confidence_threshold=confidence_threshold)
         
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def detect_ui_elements(
         self,
@@ -195,7 +204,7 @@ class OpenAIVisionService(BaseVisionService, VisionPromptMixin):
         """
         prompt = self.get_task_prompt("detect_ui_elements", element_types=element_types, confidence_threshold=confidence_threshold)
         
-        return await self.analyze_image(image, prompt)
+        return await self.analyze_image(image, prompt, max_tokens=1000)
     
     async def detect_document_elements(
         self,