isa-model 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

isa_model/inference/services/llm/yyds_llm_service.py

@@ -0,0 +1,255 @@
+import logging
+from typing import Dict, Any, List, Union, AsyncGenerator
+
+# (�� OpenAI �
+from openai import AsyncOpenAI
+
+from isa_model.inference.services.llm.base_llm_service import BaseLLMService
+
+logger = logging.getLogger(__name__)
+
+class YydsLLMService(BaseLLMService):
+    """YYDS LLM service implementation with unified invoke interface"""
+    
+    def __init__(self, provider_name: str, model_name: str = "claude-sonnet-4-20250514", **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
+        
+        # Get configuration from centralized config manager
+        provider_config = self.get_provider_config()
+        
+        # Initialize AsyncOpenAI client with provider configuration
+        try:
+            if not provider_config.get("api_key"):
+                raise ValueError("YYDS API key not found in provider configuration")
+            
+            self.client = AsyncOpenAI(
+                api_key=provider_config["api_key"],
+                base_url=provider_config.get("base_url") or provider_config.get("api_base_url", "https://api.yyds.com/v1"),
+                organization=provider_config.get("organization")
+            )
+            
+            logger.info(f"Initialized YydsLLMService with model {self.model_name} and endpoint {self.client.base_url}")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize YYDS client: {e}")
+            raise ValueError(f"Failed to initialize YYDS client. Check your API key configuration: {e}") from e
+            
+        self.last_token_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+        self.total_token_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0, "requests_count": 0}
+        
+    
+    def _create_bound_copy(self) -> 'YydsLLMService':
+        """Create a copy of this service for tool binding"""
+        bound_service = YydsLLMService(self.provider_name, self.model_name)
+        bound_service._bound_tools = self._bound_tools.copy()
+        return bound_service
+    
+    def bind_tools(self, tools: List[Any], **kwargs) -> 'YydsLLMService':
+        """
+        Bind tools to this LLM service for function calling
+        
+        Args:
+            tools: List of tools (functions, dicts, or LangChain tools)
+            **kwargs: Additional arguments for tool binding
+            
+        Returns:
+            New LLM service instance with tools bound
+        """
+        # Create a copy of this service
+        bound_service = self._create_bound_copy()
+        
+        # Use base class method to bind tools
+        bound_service._bound_tools = tools
+        
+        return bound_service
+    
+    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any]) -> AsyncGenerator[str, None]:
+        """
+        True streaming method - yields tokens one by one as they arrive
+        
+        Args:
+            input_data: Same as ainvoke
+            
+        Yields:
+            Individual tokens as they arrive from the API
+        """
+        try:
+            # Use adapter manager to prepare messages
+            messages = self._prepare_messages(input_data)
+            
+            # Prepare request kwargs
+            provider_config = self.get_provider_config()
+            kwargs = {
+                "model": self.model_name,
+                "messages": messages,
+                "temperature": provider_config.get("temperature", 0.7),
+                "max_tokens": provider_config.get("max_tokens", 1024),
+                "stream": True
+            }
+            
+            # Add tools if bound using adapter manager
+            tool_schemas = await self._prepare_tools_for_request()
+            if tool_schemas:
+                kwargs["tools"] = tool_schemas
+                kwargs["tool_choice"] = "auto"
+            
+            # Stream tokens one by one
+            content_chunks = []
+            try:
+                stream = await self.client.chat.completions.create(**kwargs)
+                async for chunk in stream:
+                    content = chunk.choices[0].delta.content
+                    if content:
+                        content_chunks.append(content)
+                        yield content
+                
+                # Track usage after streaming is complete
+                full_content = "".join(content_chunks)
+                await self._track_streaming_usage(messages, full_content)
+                
+            except Exception as e:
+                logger.error(f"Error in streaming: {e}")
+                raise
+            
+        except Exception as e:
+            logger.error(f"Error in astream: {e}")
+            raise
+    
+    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any]) -> Union[str, Any]:
+        """Unified invoke method for all input types"""
+        try:
+            # Use adapter manager to prepare messages
+            messages = self._prepare_messages(input_data)
+            
+            # Prepare request kwargs
+            provider_config = self.get_provider_config()
+            kwargs = {
+                "model": self.model_name,
+                "messages": messages,
+                "temperature": provider_config.get("temperature", 0.7),
+                "max_tokens": provider_config.get("max_tokens", 1024)
+            }
+            
+            # Add tools if bound using adapter manager
+            tool_schemas = await self._prepare_tools_for_request()
+            if tool_schemas:
+                kwargs["tools"] = tool_schemas
+                kwargs["tool_choice"] = "auto"
+            
+            # 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):
+                    content_chunks.append(token)
+                content = "".join(content_chunks)
+                
+                return self._format_response(content, input_data)
+            else:
+                # Non-streaming mode
+                response = await self.client.chat.completions.create(**kwargs)
+                message = response.choices[0].message
+                
+                # Update usage tracking
+                if response.usage:
+                    self._update_token_usage(response.usage)
+                    await self._track_billing(response.usage)
+                
+                # Handle tool calls if present - let adapter process the complete message
+                if message.tool_calls:
+                    # Pass the complete message object to adapter for proper tool_calls handling
+                    return self._format_response(message, input_data)
+                
+                # Return appropriate format based on input type
+                return self._format_response(message.content or "", input_data)
+            
+        except Exception as e:
+            logger.error(f"Error in ainvoke: {e}")
+            raise
+    
+    async def _track_streaming_usage(self, messages: List[Dict[str, str]], content: str):
+        """Track usage for streaming requests (estimated)"""
+        # Create a mock usage object for tracking
+        class MockUsage:
+            def __init__(self):
+                self.prompt_tokens = len(str(messages)) // 4  # Rough estimate
+                self.completion_tokens = len(content) // 4   # Rough estimate  
+                self.total_tokens = self.prompt_tokens + self.completion_tokens
+        
+        usage = MockUsage()
+        self._update_token_usage(usage)
+        await self._track_billing(usage)
+    
+    async def _stream_response(self, kwargs: Dict[str, Any]) -> AsyncGenerator[str, None]:
+        """Handle streaming responses - DEPRECATED: Use astream() instead"""
+        kwargs["stream"] = True
+        
+        async def stream_generator():
+            try:
+                stream = await self.client.chat.completions.create(**kwargs)
+                async for chunk in stream:
+                    content = chunk.choices[0].delta.content
+                    if content:
+                        yield content
+            except Exception as e:
+                logger.error(f"Error in streaming: {e}")
+                raise
+        
+        return stream_generator()
+    
+    
+    def _update_token_usage(self, usage):
+        """Update token usage statistics"""
+        self.last_token_usage = {
+            "prompt_tokens": usage.prompt_tokens,
+            "completion_tokens": usage.completion_tokens,
+            "total_tokens": usage.total_tokens
+        }
+        
+        # Update total usage
+        self.total_token_usage["prompt_tokens"] += self.last_token_usage["prompt_tokens"]
+        self.total_token_usage["completion_tokens"] += self.last_token_usage["completion_tokens"]
+        self.total_token_usage["total_tokens"] += self.last_token_usage["total_tokens"]
+        self.total_token_usage["requests_count"] += 1
+    
+    async def _track_billing(self, usage):
+        """Track billing information using unified billing system"""
+        provider_config = self.get_provider_config()
+        await self._track_llm_usage(
+            operation="chat",
+            input_tokens=usage.prompt_tokens,
+            output_tokens=usage.completion_tokens,
+            metadata={
+                "temperature": provider_config.get("temperature", 0.7), 
+                "max_tokens": provider_config.get("max_tokens", 1024)
+            }
+        )
+    
+    def get_token_usage(self) -> Dict[str, Any]:
+        """Get total token usage statistics"""
+        return self.total_token_usage
+    
+    def get_last_token_usage(self) -> Dict[str, int]:
+        """Get token usage from last request"""
+        return self.last_token_usage
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the current model"""
+        provider_config = self.get_provider_config()
+        return {
+            "name": self.model_name,
+            "max_tokens": provider_config.get("max_tokens", 1024),
+            "supports_streaming": True,
+            "supports_functions": True,
+            "provider": "yyds",
+            "pricing": {
+                "input_tokens_per_1k": 0.0045,
+                "output_tokens_per_1k": 0.0225,
+                "currency": "USD"
+            }
+        }
+    
+        
+    async def close(self):
+        """Close the backend client"""
+        await self.client.close()

isa_model/inference/services/vision/__init__.py

@@ -3,10 +3,44 @@
 
 """
 Vision服务包
-包含所有视觉相关服务模块
+包含所有视觉相关服务模块，包括stacked services
 """
 
-# 导出ReplicateImageGenService
-from isa_model.inference.services.vision.replicate_image_gen_service import ReplicateImageGenService
+# Vision understanding services
+from .base_vision_service import BaseVisionService  
+from .openai_vision_service import OpenAIVisionService
+from .replicate_vision_service import ReplicateVisionService
 
-__all__ = ["ReplicateImageGenService"] 
+# Stacked Vision Services
+from .doc_analysis_service import DocAnalysisStackedService
+from .ui_analysis_service import UIAnalysisService
+
+# ISA Vision service
+try:
+    from .isA_vision_service import ISAVisionService
+    ISA_VISION_AVAILABLE = True
+except ImportError:
+    ISAVisionService = None
+    ISA_VISION_AVAILABLE = False
+
+# Optional services - import only if available
+try:
+    from .ollama_vision_service import OllamaVisionService
+    OLLAMA_VISION_AVAILABLE = True
+except ImportError:
+    OllamaVisionService = None
+    OLLAMA_VISION_AVAILABLE = False
+
+__all__ = [
+    "BaseVisionService",
+    "OpenAIVisionService", 
+    "ReplicateVisionService",
+    "DocAnalysisStackedService",
+    "UIAnalysisService"
+]
+
+if ISA_VISION_AVAILABLE:
+    __all__.append("ISAVisionService")
+
+if OLLAMA_VISION_AVAILABLE:
+    __all__.append("OllamaVisionService")