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

isa_model/inference/services/base_service.py

@@ -1,19 +1,50 @@
 from abc import ABC, abstractmethod
 from typing import Dict, Any, List, Union, AsyncGenerator, TypeVar, Optional
-from isa_model.inference.providers.base_provider import BaseProvider
-from isa_model.inference.billing_tracker import track_usage, ServiceType, Provider
+from ...core.models.model_manager import ModelManager
+from ...core.config.config_manager import ConfigManager
+from ...core.types import Provider, ServiceType
 
 T = TypeVar('T')  # Generic type for responses
 
 class BaseService(ABC):
-    """Base class for all AI services"""
+    """Base class for all AI services - now uses centralized managers"""
     
-    def __init__(self, provider: 'BaseProvider', model_name: str):
-        self.provider = provider
+    def __init__(self, 
+                 provider_name: str, 
+                 model_name: str, 
+                 model_manager: Optional[ModelManager] = None,
+                 config_manager: Optional[ConfigManager] = None):
+        self.provider_name = provider_name
         self.model_name = model_name
-        self.config = provider.get_full_config()
+        self.model_manager = model_manager or ModelManager()
+        self.config_manager = config_manager or ConfigManager()
         
-    def _track_usage(
+        # Validate provider is configured
+        if not self.config_manager.is_provider_enabled(provider_name):
+            raise ValueError(f"Provider {provider_name} is not configured or enabled")
+    
+    def get_api_key(self) -> str:
+        """Get API key for the provider"""
+        api_key = self.config_manager.get_provider_api_key(self.provider_name)
+        if not api_key:
+            raise ValueError(f"No API key configured for provider {self.provider_name}")
+        return api_key
+    
+    def get_provider_config(self) -> Dict[str, Any]:
+        """Get provider configuration"""
+        config = self.config_manager.get_provider_config(self.provider_name)
+        if not config:
+            return {}
+        
+        return {
+            "api_key": config.api_key,
+            "api_base_url": config.api_base_url,
+            "organization": config.organization,
+            "rate_limit_rpm": config.rate_limit_rpm,
+            "rate_limit_tpm": config.rate_limit_tpm,
+        }
+        
+    async def _track_usage(
         self,
         service_type: Union[str, ServiceType],
         operation: str,
@@ -23,23 +54,30 @@ class BaseService(ABC):
         output_units: Optional[float] = None,
         metadata: Optional[Dict[str, Any]] = None
     ):
-        """Track usage for billing purposes"""
+        """Track usage for billing purposes using centralized billing tracker"""
         try:
-            # Determine provider name - try multiple attributes
-            provider_name = getattr(self.provider, 'name', None) or \
-                          getattr(self.provider, 'provider_name', None) or \
-                          getattr(self.provider, '__class__', type(None)).__name__.lower().replace('provider', '') or \
-                          'unknown'
+            # Calculate cost using centralized pricing
+            cost_usd = None
+            if input_tokens is not None and output_tokens is not None:
+                cost_usd = self.model_manager.calculate_cost(
+                    provider=self.provider_name,
+                    model_name=self.model_name,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens
+                )
             
-            track_usage(
-                provider=provider_name,
-                service_type=service_type,
-                model_name=self.model_name,
+            # Track usage through model manager
+            self.model_manager.billing_tracker.track_model_usage(
+                model_id=self.model_name,
+                operation_type="inference",
+                provider=self.provider_name,
+                service_type=service_type if isinstance(service_type, str) else service_type.value,
                 operation=operation,
                 input_tokens=input_tokens,
                 output_tokens=output_tokens,
                 input_units=input_units,
                 output_units=output_units,
+                cost_usd=cost_usd,
                 metadata=metadata
             )
         except Exception as e:
@@ -52,44 +90,6 @@ class BaseService(ABC):
         yield
         return self
 
-class BaseLLMService(BaseService):
-    """Base class for LLM services"""
-    
-    @abstractmethod
-    async def ainvoke(self, prompt: Union[str, List[Dict[str, str]], Any]) -> T:
-        """Universal invocation method"""
-        pass
-    
-    @abstractmethod
-    async def achat(self, messages: List[Dict[str, str]]) -> T:
-        """Chat completion method"""
-        pass
-    
-    @abstractmethod
-    async def acompletion(self, prompt: str) -> T:
-        """Text completion method"""
-        pass
-    
-    @abstractmethod
-    async def agenerate(self, messages: List[Dict[str, str]], n: int = 1) -> List[T]:
-        """Generate multiple completions"""
-        pass
-    
-    @abstractmethod
-    async def astream_chat(self, messages: List[Dict[str, str]]) -> AsyncGenerator[str, None]:
-        """Stream chat responses"""
-        pass
-    
-    @abstractmethod
-    def get_token_usage(self) -> Any:
-        """Get total token usage statistics"""
-        pass
-    
-    @abstractmethod
-    def get_last_token_usage(self) -> Dict[str, int]:
-        """Get token usage from last request"""
-        pass
-
 class BaseEmbeddingService(BaseService):
     """Base class for embedding services"""
     

isa_model/inference/services/embedding/base_embed_service.py

@@ -3,7 +3,71 @@ from typing import Dict, Any, List, Union, Optional
 from isa_model.inference.services.base_service import BaseService
 
 class BaseEmbedService(BaseService):
-    """Base class for embedding services"""
+    """Base class for embedding services with unified task dispatch"""
+    
+    async def invoke(
+        self, 
+        input_data: Union[str, List[str]],
+        task: Optional[str] = None,
+        **kwargs
+    ) -> Union[List[float], List[List[float]], List[Dict[str, Any]], Dict[str, Any]]:
+        """
+        统一的任务分发方法 - Base类提供通用实现
+        
+        Args:
+            input_data: 输入数据，可以是:
+                - str: 单个文本
+                - List[str]: 多个文本（批量处理）
+            task: 任务类型，支持多种embedding任务
+            **kwargs: 任务特定的附加参数
+            
+        Returns:
+            Various types depending on task
+        """
+        task = task or "embed"
+        
+        # ==================== 嵌入生成类任务 ====================
+        if task == "embed":
+            if isinstance(input_data, list):
+                return await self.create_text_embeddings(input_data)
+            else:
+                return await self.create_text_embedding(input_data)
+        elif task == "embed_batch":
+            if not isinstance(input_data, list):
+                input_data = [input_data]
+            return await self.create_text_embeddings(input_data)
+        elif task == "chunk_and_embed":
+            if isinstance(input_data, list):
+                raise ValueError("chunk_and_embed task requires single text input")
+            return await self.create_chunks(input_data, kwargs.get("metadata"))
+        elif task == "similarity":
+            embedding1 = kwargs.get("embedding1")
+            embedding2 = kwargs.get("embedding2")
+            if not embedding1 or not embedding2:
+                raise ValueError("similarity task requires embedding1 and embedding2 parameters")
+            similarity = await self.compute_similarity(embedding1, embedding2)
+            return {"similarity": similarity}
+        elif task == "find_similar":
+            query_embedding = kwargs.get("query_embedding")
+            candidate_embeddings = kwargs.get("candidate_embeddings")
+            if not query_embedding or not candidate_embeddings:
+                raise ValueError("find_similar task requires query_embedding and candidate_embeddings parameters")
+            return await self.find_similar_texts(
+                query_embedding, 
+                candidate_embeddings, 
+                kwargs.get("top_k", 5)
+            )
+        else:
+            raise NotImplementedError(f"{self.__class__.__name__} does not support task: {task}")
+    
+    def get_supported_tasks(self) -> List[str]:
+        """
+        获取支持的任务列表
+        
+        Returns:
+            List of supported task names
+        """
+        return ["embed", "embed_batch", "chunk_and_embed", "similarity", "find_similar"]
     
     @abstractmethod
     async def create_text_embedding(self, text: str) -> List[float]:

isa_model/inference/services/embedding/ollama_embed_service.py

@@ -3,44 +3,65 @@ import httpx
 import asyncio
 from typing import List, Dict, Any, Optional
 
-# 保留您指定的导入和框架结构
 from isa_model.inference.services.embedding.base_embed_service import BaseEmbedService
-from isa_model.inference.providers.base_provider import BaseProvider
 
 logger = logging.getLogger(__name__)
 
 class OllamaEmbedService(BaseEmbedService):
     """
-    Ollama embedding service.
-    此类遵循基础服务架构，但使用其自己的 HTTP 客户端与 Ollama API 通信，
-    而不依赖于注入的 backend 对象。
+    Ollama embedding service with unified architecture.
+    Uses direct HTTP client communication with Ollama API.
     """
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "bge-m3"):
-        # 保持对基类和 provider 的兼容
-        super().__init__(provider, model_name)
+    def __init__(self, provider_name: str, model_name: str = "bge-m3", **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
         
-        # 从基类继承的 self.config 中获取配置
-        host = self.config.get("host", "localhost")
-        port = self.config.get("port", 11434)
+        # Get configuration from centralized config manager
+        provider_config = self.get_provider_config()
         
-        # 创建并持有自己的 httpx 客户端实例
-        base_url = f"http://{host}:{port}"
-        self.client = httpx.AsyncClient(base_url=base_url, timeout=30.0)
+        # Initialize HTTP client with provider configuration
+        try:
+            host = provider_config.get("host", "localhost")
+            port = provider_config.get("port", 11434)
+            base_url = f"http://{host}:{port}"
+            
+            self.client = httpx.AsyncClient(base_url=base_url, timeout=30.0)
             
-        logger.info(f"Initialized OllamaEmbedService with model '{self.model_name}' at {base_url}")
+            logger.info(f"Initialized OllamaEmbedService with model '{self.model_name}' at {base_url}")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize Ollama client: {e}")
+            raise ValueError(f"Failed to initialize Ollama client: {e}") from e
     
     async def create_text_embedding(self, text: str) -> List[float]:
-        """为单个文本创建 embedding"""
+        """Create embedding for single text"""
         try:
             payload = {
                 "model": self.model_name,
                 "prompt": text
             }
-            # 使用自己的 client 实例，而不是 self.backend
+            
             response = await self.client.post("/api/embeddings", json=payload)
-            response.raise_for_status() # 检查请求是否成功
-            return response.json()["embedding"]
+            response.raise_for_status()
+            
+            result = response.json()
+            embedding = result["embedding"]
+            
+            # Track usage for billing (estimate token usage for Ollama)
+            estimated_tokens = len(text.split()) * 1.3  # Rough estimation
+            await self._track_usage(
+                service_type="embedding",
+                operation="create_text_embedding",
+                input_tokens=int(estimated_tokens),
+                output_tokens=0,
+                metadata={
+                    "model": self.model_name,
+                    "text_length": len(text),
+                    "estimated_tokens": int(estimated_tokens)
+                }
+            )
+            
+            return embedding
             
         except httpx.RequestError as e:
             logger.error(f"An error occurred while requesting {e.request.url!r}: {e}")
@@ -50,41 +71,70 @@ class OllamaEmbedService(BaseEmbedService):
             raise
     
     async def create_text_embeddings(self, texts: List[str]) -> List[List[float]]:
-        """为多个文本并发地创建 embeddings"""
+        """Create embeddings for multiple texts concurrently"""
         if not texts:
             return []
         
         tasks = [self.create_text_embedding(text) for text in texts]
         embeddings = await asyncio.gather(*tasks)
+        
+        # Track batch usage for billing
+        total_estimated_tokens = sum(len(text.split()) * 1.3 for text in texts)
+        await self._track_usage(
+            service_type="embedding",
+            operation="create_text_embeddings",
+            input_tokens=int(total_estimated_tokens),
+            output_tokens=0,
+            metadata={
+                "model": self.model_name,
+                "batch_size": len(texts),
+                "total_text_length": sum(len(t) for t in texts),
+                "estimated_tokens": int(total_estimated_tokens)
+            }
+        )
+        
         return embeddings
     
     async def create_chunks(self, text: str, metadata: Optional[Dict] = None) -> List[Dict]:
-        """将文本分块并为每个块创建 embedding"""
-        chunk_size = 200  # 单词数量
-        words = text.split()
-        chunk_texts = [" ".join(words[i:i+chunk_size]) for i in range(0, len(words), chunk_size)]
+        """Create text chunks with embeddings"""
+        chunk_size = 200  # words
+        overlap = 50     # word overlap between chunks
         
-        if not chunk_texts:
+        words = text.split()
+        if not words:
             return []
-
-        embeddings = await self.create_text_embeddings(chunk_texts)
         
-        chunks = [
-            {
+        chunks = []
+        chunk_texts = []
+        
+        for i in range(0, len(words), chunk_size - overlap):
+            chunk_words = words[i:i + chunk_size]
+            chunk_text = " ".join(chunk_words)
+            chunk_texts.append(chunk_text)
+            
+            chunks.append({
                 "text": chunk_text,
-                "embedding": emb,
+                "start_index": i,
+                "end_index": min(i + chunk_size, len(words)),
                 "metadata": metadata or {}
-            }
-            for chunk_text, emb in zip(chunk_texts, embeddings)
-        ]
-            
+            })
+        
+        # Get embeddings for all chunks
+        embeddings = await self.create_text_embeddings(chunk_texts)
+        
+        # Add embeddings to chunks
+        for chunk, embedding in zip(chunks, embeddings):
+            chunk["embedding"] = embedding
+        
         return chunks
     
     async def compute_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
-        """计算两个嵌入向量之间的余弦相似度"""
+        """Compute cosine similarity between two embeddings"""
+        import math
+        
         dot_product = sum(a * b for a, b in zip(embedding1, embedding2))
-        norm1 = sum(a * a for a in embedding1) ** 0.5
-        norm2 = sum(b * b for b in embedding2) ** 0.5
+        norm1 = math.sqrt(sum(a * a for a in embedding1))
+        norm2 = math.sqrt(sum(b * b for b in embedding2))
         
         if norm1 * norm2 == 0:
             return 0.0
@@ -99,9 +149,13 @@ class OllamaEmbedService(BaseEmbedService):
     ) -> List[Dict[str, Any]]:
         """Find most similar texts based on embeddings"""
         similarities = []
+        
         for i, candidate in enumerate(candidate_embeddings):
             similarity = await self.compute_similarity(query_embedding, candidate)
-            similarities.append({"index": i, "similarity": similarity})
+            similarities.append({
+                "index": i, 
+                "similarity": similarity
+            })
         
         # Sort by similarity in descending order and return top_k
         similarities.sort(key=lambda x: x["similarity"], reverse=True)
@@ -109,15 +163,21 @@ class OllamaEmbedService(BaseEmbedService):
     
     def get_embedding_dimension(self) -> int:
         """Get the dimension of embeddings produced by this service"""
-        # BGE-M3 produces 1024-dimensional embeddings
-        return 1024
+        # Model-specific dimensions
+        model_dimensions = {
+            "bge-m3": 1024,
+            "bge-large": 1024,
+            "all-minilm": 384,
+            "nomic-embed-text": 768
+        }
+        return model_dimensions.get(self.model_name, 1024)
     
     def get_max_input_length(self) -> int:
         """Get maximum input text length supported"""
-        # BGE-M3 supports up to 8192 tokens
+        # Most Ollama embedding models support up to 8192 tokens
         return 8192
 
     async def close(self):
-        """关闭内置的 HTTP 客户端"""
+        """Cleanup resources"""
         await self.client.aclose()
-        logger.info("OllamaEmbedService's internal client has been closed.")
+        logger.info("OllamaEmbedService client has been closed.")

isa_model/inference/services/embedding/openai_embed_service.py

@@ -5,8 +5,6 @@ from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential
 
 from isa_model.inference.services.embedding.base_embed_service import BaseEmbedService
-from isa_model.inference.providers.base_provider import BaseProvider
-from isa_model.inference.billing_tracker import ServiceType
 
 logger = logging.getLogger(__name__)
 
@@ -16,11 +14,11 @@ class OpenAIEmbedService(BaseEmbedService):
     Provides high-quality embeddings for production use.
     """
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "text-embedding-3-small"):
-        super().__init__(provider, model_name)
+    def __init__(self, provider_name: str, model_name: str = "text-embedding-3-small", **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
         
-        # Get full configuration from provider (including sensitive data)
-        provider_config = provider.get_full_config()
+        # Get configuration from centralized config manager
+        provider_config = self.get_provider_config()
         
         # Initialize AsyncOpenAI client with provider configuration
         try:
@@ -67,8 +65,8 @@ class OpenAIEmbedService(BaseEmbedService):
             usage = getattr(response, 'usage', None)
             if usage:
                 total_tokens = getattr(usage, 'total_tokens', 0)
-                self._track_usage(
-                    service_type=ServiceType.EMBEDDING,
+                await self._track_usage(
+                    service_type="embedding",
                     operation="create_text_embedding",
                     input_tokens=total_tokens,
                     output_tokens=0,
@@ -112,8 +110,8 @@ class OpenAIEmbedService(BaseEmbedService):
             usage = getattr(response, 'usage', None)
             if usage:
                 total_tokens = getattr(usage, 'total_tokens', 0)
-                self._track_usage(
-                    service_type=ServiceType.EMBEDDING,
+                await self._track_usage(
+                    service_type="embedding",
                     operation="create_text_embeddings",
                     input_tokens=total_tokens,
                     output_tokens=0,

isa_model/inference/services/helpers/stacked_config.py

@@ -0,0 +1,148 @@
+"""
+Configuration system for stacked services
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+
+# Define stacked service specific layer types
+class StackedLayerType(Enum):
+    """Types of processing layers for stacked services"""
+    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: StackedLayerType
+    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 WorkflowType(Enum):
+    """Predefined workflow types"""
+    UI_ANALYSIS_FAST = "ui_analysis_fast"
+    UI_ANALYSIS_ACCURATE = "ui_analysis_accurate"
+    UI_ANALYSIS_COMPREHENSIVE = "ui_analysis_comprehensive"
+    SEARCH_PAGE_ANALYSIS = "search_page_analysis"
+    CONTENT_EXTRACTION = "content_extraction"
+    FORM_INTERACTION = "form_interaction"
+    NAVIGATION_ANALYSIS = "navigation_analysis"
+    CUSTOM = "custom"
+
+@dataclass
+class StackedServiceConfig:
+    """Configuration for a stacked service workflow"""
+    name: str
+    workflow_type: WorkflowType
+    layers: List[LayerConfig] = field(default_factory=list)
+    global_timeout: float = 120.0
+    parallel_execution: bool = False
+    fail_fast: bool = False
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+class ConfigManager:
+    """Manager for stacked service configurations"""
+    
+    PREDEFINED_CONFIGS = {
+        WorkflowType.UI_ANALYSIS_FAST: {
+            "name": "Fast UI Analysis",
+            "layers": [
+                LayerConfig(
+                    name="page_intelligence",
+                    layer_type=StackedLayerType.INTELLIGENCE,
+                    service_type="vision",
+                    model_name="gpt-4.1-nano",
+                    parameters={"max_tokens": 300},
+                    depends_on=[],
+                    timeout=10.0,
+                    fallback_enabled=True
+                ),
+                LayerConfig(
+                    name="element_detection",
+                    layer_type=StackedLayerType.DETECTION,
+                    service_type="vision",
+                    model_name="omniparser",
+                    parameters={
+                        "imgsz": 480,
+                        "box_threshold": 0.08,
+                        "iou_threshold": 0.2
+                    },
+                    depends_on=["page_intelligence"],
+                    timeout=15.0,
+                    fallback_enabled=True
+                ),
+                LayerConfig(
+                    name="element_classification",
+                    layer_type=StackedLayerType.CLASSIFICATION,
+                    service_type="vision",
+                    model_name="gpt-4.1-nano",
+                    parameters={"max_tokens": 200},
+                    depends_on=["page_intelligence", "element_detection"],
+                    timeout=20.0,
+                    fallback_enabled=False
+                )
+            ],
+            "global_timeout": 60.0,
+            "parallel_execution": False,
+            "fail_fast": False,
+            "metadata": {
+                "description": "Fast UI analysis optimized for speed",
+                "expected_time": "30-45 seconds",
+                "accuracy": "medium"
+            }
+        }
+    }
+    
+    @classmethod
+    def get_config(cls, workflow_type: WorkflowType) -> StackedServiceConfig:
+        """Get predefined configuration for a workflow type"""
+        if workflow_type not in cls.PREDEFINED_CONFIGS:
+            raise ValueError(f"Unknown workflow type: {workflow_type}")
+        
+        config_data = cls.PREDEFINED_CONFIGS[workflow_type]
+        
+        return StackedServiceConfig(
+            name=config_data["name"],
+            workflow_type=workflow_type,
+            layers=config_data["layers"],
+            global_timeout=config_data["global_timeout"],
+            parallel_execution=config_data["parallel_execution"],
+            fail_fast=config_data["fail_fast"],
+            metadata=config_data["metadata"]
+        )
+
+# Convenience function for quick access
+def get_ui_analysis_config(speed: str = "accurate") -> StackedServiceConfig:
+    """Get UI analysis configuration by speed preference"""
+    speed_mapping = {
+        "fast": WorkflowType.UI_ANALYSIS_FAST,
+        "accurate": WorkflowType.UI_ANALYSIS_ACCURATE,
+        "comprehensive": WorkflowType.UI_ANALYSIS_COMPREHENSIVE
+    }
+    
+    workflow_type = speed_mapping.get(speed.lower(), WorkflowType.UI_ANALYSIS_ACCURATE)
+    return ConfigManager.get_config(workflow_type)

isa_model/inference/services/img/__init__.py

@@ -0,0 +1,18 @@
+"""
+Image Generation Services
+
+This module contains services for image generation, separate from vision understanding.
+Including stacked services for complex image generation pipelines.
+"""
+
+from .base_image_gen_service import BaseImageGenService
+from .replicate_image_gen_service import ReplicateImageGenService
+
+# Stacked Image Generation Services  
+from .flux_professional_service import FluxProfessionalService
+
+__all__ = [
+    'BaseImageGenService',
+    'ReplicateImageGenService',
+    'FluxProfessionalService'
+]