isa-model 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

isa_model/inference/services/llm/yyds_llm_service.py

@@ -0,0 +1,254 @@
+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
+from isa_model.inference.providers.base_provider import BaseProvider
+from isa_model.inference.billing_tracker import ServiceType
+
+logger = logging.getLogger(__name__)
+
+class YydsLLMService(BaseLLMService):
+    """YYDS LLM service implementation with unified invoke interface"""
+    
+    def __init__(self, provider: 'BaseProvider', model_name: str = "claude-sonnet-4-20250514"):
+        super().__init__(provider, model_name)
+        
+        # Get full configuration from provider (including sensitive data)
+        provider_config = provider.get_full_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", "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, 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
+            kwargs = {
+                "model": self.model_name,
+                "messages": messages,
+                "temperature": self.config.get("temperature", 0.7),
+                "max_tokens": self.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)
+                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
+            kwargs = {
+                "model": self.model_name,
+                "messages": messages,
+                "temperature": self.config.get("temperature", 0.7),
+                "max_tokens": self.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)
+                    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
+    
+    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)
+        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
+    
+    def _track_billing(self, usage):
+        """Track billing information"""
+        self._track_usage(
+            service_type=ServiceType.LLM,
+            operation="chat",
+            input_tokens=usage.prompt_tokens,
+            output_tokens=usage.completion_tokens,
+            metadata={
+                "temperature": self.config.get("temperature", 0.7), 
+                "max_tokens": self.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"""
+        return {
+            "name": self.model_name,
+            "max_tokens": self.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/stacked/__init__.py

@@ -0,0 +1,26 @@
+"""
+Stacked Services - Multi-model orchestration services
+
+This module provides stacked services that combine multiple AI models 
+in sequence or parallel to solve complex tasks.
+"""
+
+from .base_stacked_service import BaseStackedService, LayerConfig, LayerType, LayerResult
+from .ui_analysis_service import UIAnalysisService
+from .doc_analysis_service import DocAnalysisStackedService
+from .flux_professional_service import FluxProfessionalService
+from .config import ConfigManager, StackedServiceConfig, WorkflowType, get_ui_analysis_config
+
+__all__ = [
+    'BaseStackedService',
+    'LayerConfig', 
+    'LayerType',
+    'LayerResult',
+    'UIAnalysisService',
+    'DocAnalysisStackedService',
+    'FluxProfessionalService',
+    'ConfigManager',
+    'StackedServiceConfig',
+    'WorkflowType',
+    'get_ui_analysis_config'
+]

isa_model/inference/services/stacked/base_stacked_service.py

@@ -0,0 +1,269 @@
+"""
+Base Stacked Service for orchestrating multiple AI models
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional, Union, Callable
+import time
+import asyncio
+import logging
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+class LayerType(Enum):
+    """Types of processing layers"""
+    INTELLIGENCE = "intelligence"      # High-level understanding
+    DETECTION = "detection"           # Element/object detection  
+    CLASSIFICATION = "classification" # Detailed classification
+    VALIDATION = "validation"         # Result validation
+    TRANSFORMATION = "transformation" # Data transformation
+    GENERATION = "generation"         # Content generation
+    ENHANCEMENT = "enhancement"       # Quality enhancement
+    CONTROL = "control"              # Precise control/refinement
+    UPSCALING = "upscaling"          # Resolution enhancement
+
+@dataclass
+class LayerConfig:
+    """Configuration for a processing layer"""
+    name: str
+    layer_type: LayerType
+    service_type: str                  # e.g., 'vision', 'llm'
+    model_name: str
+    parameters: Dict[str, Any]
+    depends_on: List[str]             # Layer dependencies
+    timeout: float = 30.0
+    retry_count: int = 1
+    fallback_enabled: bool = True
+
+@dataclass
+class LayerResult:
+    """Result from a processing layer"""
+    layer_name: str
+    success: bool
+    data: Any
+    metadata: Dict[str, Any]
+    execution_time: float
+    error: Optional[str] = None
+
+class BaseStackedService(ABC):
+    """
+    Base class for stacked services that orchestrate multiple AI models
+    """
+    
+    def __init__(self, ai_factory, service_name: str):
+        self.ai_factory = ai_factory
+        self.service_name = service_name
+        self.layers: List[LayerConfig] = []
+        self.services: Dict[str, Any] = {}
+        self.results: Dict[str, LayerResult] = {}
+        
+    def add_layer(self, config: LayerConfig):
+        """Add a processing layer to the stack"""
+        self.layers.append(config)
+        logger.info(f"Added layer {config.name} ({config.layer_type.value}) to {self.service_name}")
+    
+    async def initialize_services(self):
+        """Initialize all required services"""
+        for layer in self.layers:
+            service_key = f"{layer.service_type}_{layer.model_name}"
+            
+            if service_key not in self.services:
+                if layer.service_type == 'vision':
+                    if layer.model_name == "default":
+                        # 使用默认vision服务
+                        service = self.ai_factory.get_vision()
+                    elif layer.model_name == "omniparser":
+                        # 使用replicate omniparser
+                        service = self.ai_factory.get_vision(model_name="omniparser", provider="replicate")
+                    else:
+                        # 其他指定模型
+                        service = self.ai_factory.get_vision(model_name=layer.model_name)
+                elif layer.service_type == 'llm':
+                    if layer.model_name == "default":
+                        service = self.ai_factory.get_llm()
+                    else:
+                        service = self.ai_factory.get_llm(model_name=layer.model_name)
+                elif layer.service_type == 'image_gen':
+                    if layer.model_name == "default":
+                        service = self.ai_factory.get_image_gen()
+                    else:
+                        service = self.ai_factory.get_image_gen(model_name=layer.model_name)
+                else:
+                    raise ValueError(f"Unsupported service type: {layer.service_type}")
+                
+                self.services[service_key] = service
+                logger.info(f"Initialized {service_key} service")
+    
+    async def execute_layer(self, layer: LayerConfig, context: Dict[str, Any]) -> LayerResult:
+        """Execute a single layer"""
+        start_time = time.time()
+        
+        try:
+            # Check dependencies
+            for dep in layer.depends_on:
+                if dep not in self.results or not self.results[dep].success:
+                    raise ValueError(f"Dependency {dep} failed or not executed")
+            
+            # Get the service
+            service_key = f"{layer.service_type}_{layer.model_name}"
+            service = self.services[service_key]
+            
+            # Execute layer with timeout
+            data = await asyncio.wait_for(
+                self.execute_layer_logic(layer, service, context),
+                timeout=layer.timeout
+            )
+            
+            execution_time = time.time() - start_time
+            
+            result = LayerResult(
+                layer_name=layer.name,
+                success=True,
+                data=data,
+                metadata={
+                    "layer_type": layer.layer_type.value,
+                    "model": layer.model_name,
+                    "parameters": layer.parameters
+                },
+                execution_time=execution_time
+            )
+            
+            logger.info(f"Layer {layer.name} completed in {execution_time:.2f}s")
+            return result
+            
+        except Exception as e:
+            execution_time = time.time() - start_time
+            error_msg = str(e)
+            
+            logger.error(f"Layer {layer.name} failed after {execution_time:.2f}s: {error_msg}")
+            
+            result = LayerResult(
+                layer_name=layer.name,
+                success=False,
+                data=None,
+                metadata={
+                    "layer_type": layer.layer_type.value,
+                    "model": layer.model_name,
+                    "parameters": layer.parameters
+                },
+                execution_time=execution_time,
+                error=error_msg
+            )
+            
+            # Try fallback if enabled
+            if layer.fallback_enabled:
+                fallback_result = await self.execute_fallback(layer, context, error_msg)
+                if fallback_result:
+                    result.data = fallback_result
+                    result.success = True
+                    result.error = f"Fallback used: {error_msg}"
+            
+            return result
+    
+    @abstractmethod
+    async def execute_layer_logic(self, layer: LayerConfig, service: Any, context: Dict[str, Any]) -> Any:
+        """Execute the specific logic for a layer - to be implemented by subclasses"""
+        pass
+    
+    async def execute_fallback(self, layer: LayerConfig, context: Dict[str, Any], error: str) -> Optional[Any]:
+        """Execute fallback logic for a failed layer - can be overridden by subclasses"""
+        return None
+    
+    async def invoke(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke the entire stack of layers"""
+        logger.info(f"Starting {self.service_name} stack invocation")
+        stack_start_time = time.time()
+        
+        # Initialize services if not done
+        if not self.services:
+            await self.initialize_services()
+        
+        # Clear previous results
+        self.results.clear()
+        
+        # Build execution order based on dependencies
+        execution_order = self._build_execution_order()
+        
+        # Execute layers in order
+        context = {"input": input_data, "results": self.results}
+        
+        for layer in execution_order:
+            result = await self.execute_layer(layer, context)
+            self.results[layer.name] = result
+            
+            # Update context with result
+            context["results"] = self.results
+            
+            # Stop if critical layer fails
+            if not result.success and not layer.fallback_enabled:
+                logger.error(f"Critical layer {layer.name} failed, stopping execution")
+                break
+        
+        total_time = time.time() - stack_start_time
+        
+        # Generate final result
+        final_result = {
+            "service": self.service_name,
+            "success": all(r.success for r in self.results.values()),
+            "total_execution_time": total_time,
+            "layer_results": {name: result for name, result in self.results.items()},
+            "final_output": self.generate_final_output(self.results)
+        }
+        
+        logger.info(f"{self.service_name} stack invocation completed in {total_time:.2f}s")
+        return final_result
+    
+    def _build_execution_order(self) -> List[LayerConfig]:
+        """Build execution order based on dependencies"""
+        # Simple topological sort
+        ordered = []
+        remaining = self.layers.copy()
+        
+        while remaining:
+            # Find layers with no unmet dependencies
+            ready = []
+            for layer in remaining:
+                deps_met = all(dep in [l.name for l in ordered] for dep in layer.depends_on)
+                if deps_met:
+                    ready.append(layer)
+            
+            if not ready:
+                raise ValueError("Circular dependency detected in layer configuration")
+            
+            # Add ready layers to order
+            ordered.extend(ready)
+            for layer in ready:
+                remaining.remove(layer)
+        
+        return ordered
+    
+    @abstractmethod
+    def generate_final_output(self, results: Dict[str, LayerResult]) -> Any:
+        """Generate final output from all layer results - to be implemented by subclasses"""
+        pass
+    
+    async def close(self):
+        """Close all services"""
+        for service in self.services.values():
+            if hasattr(service, 'close'):
+                await service.close()
+        self.services.clear()
+        logger.info(f"Closed all services for {self.service_name}")
+    
+    def get_performance_metrics(self) -> Dict[str, Any]:
+        """Get performance metrics for the stack"""
+        if not self.results:
+            return {}
+        
+        metrics = {
+            "total_layers": len(self.results),
+            "successful_layers": sum(1 for r in self.results.values() if r.success),
+            "failed_layers": sum(1 for r in self.results.values() if not r.success),
+            "total_execution_time": sum(r.execution_time for r in self.results.values()),
+            "layer_times": {name: r.execution_time for name, r in self.results.items()},
+            "layer_success": {name: r.success for name, r in self.results.items()}
+        }
+        
+        return metrics