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

isa_model/inference/services/llm/ollama_llm_service.py

@@ -3,19 +3,21 @@ import httpx
 import json
 from typing import Dict, Any, List, Union, AsyncGenerator, Optional, Callable
 from isa_model.inference.services.llm.base_llm_service import BaseLLMService
-from isa_model.inference.providers.base_provider import BaseProvider
 
 logger = logging.getLogger(__name__)
 
 class OllamaLLMService(BaseLLMService):
     """Ollama LLM service with unified invoke interface and proper adapter support"""
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "llama3.2:3b-instruct-fp16"):
-        super().__init__(provider, model_name)
+    def __init__(self, provider_name: str, model_name: str = "llama3.2:3b-instruct-fp16", **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
+        
+        # Get configuration from centralized config manager
+        provider_config = self.get_provider_config()
         
         # Create HTTP client for Ollama API
-        base_url = self.config.get("base_url", "http://localhost:11434")
-        timeout = self.config.get("timeout", 60)
+        base_url = provider_config.get("base_url", "http://localhost:11434")
+        timeout = provider_config.get("timeout", 60)
         
         self.client = httpx.AsyncClient(
             base_url=base_url,
@@ -31,13 +33,14 @@ class OllamaLLMService(BaseLLMService):
     def _ensure_client(self):
         """Ensure the HTTP client is available and not closed"""
         if not hasattr(self, 'client') or not self.client or self.client.is_closed:
-            base_url = self.config.get("base_url", "http://localhost:11434")
-            timeout = self.config.get("timeout", 60)
+            provider_config = self.get_provider_config()
+            base_url = provider_config.get("base_url", "http://localhost:11434")
+            timeout = provider_config.get("timeout", 60)
             self.client = httpx.AsyncClient(base_url=base_url, timeout=timeout)
     
     def _create_bound_copy(self) -> 'OllamaLLMService':
         """Create a copy of this service for tool binding"""
-        bound_service = OllamaLLMService(self.provider, self.model_name)
+        bound_service = OllamaLLMService(self.provider_name, self.model_name)
         bound_service._bound_tools = self._bound_tools.copy()
         return bound_service
     
@@ -70,14 +73,15 @@ class OllamaLLMService(BaseLLMService):
             messages = self._prepare_messages(input_data)
             
             # Prepare request parameters
+            provider_config = self.get_provider_config()
             payload = {
                 "model": self.model_name,
                 "messages": messages,
                 "stream": self.streaming,
                 "options": {
-                    "temperature": self.config.get("temperature", 0.7),
-                    "top_p": self.config.get("top_p", 0.9),
-                    "num_predict": self.config.get("max_tokens", 2048)
+                    "temperature": provider_config.get("temperature", 0.7),
+                    "top_p": provider_config.get("top_p", 0.9),
+                    "num_predict": provider_config.get("max_tokens", 2048)
                 }
             }
             
@@ -104,6 +108,7 @@ class OllamaLLMService(BaseLLMService):
             # Update token usage if available
             if "eval_count" in result:
                 self._update_token_usage(result)
+                await self._track_ollama_billing(result)
             
             # Handle tool calls if present - let adapter process the complete message
             message = result["message"]
@@ -196,7 +201,7 @@ class OllamaLLMService(BaseLLMService):
         # Get final response from the model
         return await self.ainvoke(messages)
     
-    def _track_streaming_usage(self, messages: List[Dict[str, str]], content: str):
+    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:
@@ -207,6 +212,18 @@ class OllamaLLMService(BaseLLMService):
         
         usage = MockUsage()
         self._update_token_usage_from_mock(usage)
+        
+        # Track billing
+        await self._track_llm_usage(
+            operation="chat_stream",
+            input_tokens=usage.prompt_tokens,
+            output_tokens=usage.completion_tokens,
+            metadata={
+                "model": self.model_name,
+                "provider": "ollama",
+                "streaming": True
+            }
+        )
     
     def _update_token_usage_from_mock(self, usage):
         """Update token usage statistics from mock usage object"""
@@ -236,6 +253,21 @@ class OllamaLLMService(BaseLLMService):
         self.total_token_usage["total_tokens"] += self.last_token_usage["total_tokens"]
         self.total_token_usage["requests_count"] += 1
     
+    async def _track_ollama_billing(self, result: Dict[str, Any]):
+        """Track billing information for Ollama requests"""
+        prompt_tokens = result.get("prompt_eval_count", 0)
+        completion_tokens = result.get("eval_count", 0)
+        
+        await self._track_llm_usage(
+            operation="chat",
+            input_tokens=prompt_tokens,
+            output_tokens=completion_tokens,
+            metadata={
+                "model": self.model_name,
+                "provider": "ollama"
+            }
+        )
+    
     def get_token_usage(self) -> Dict[str, Any]:
         """Get total token usage statistics"""
         return self.total_token_usage
@@ -246,9 +278,10 @@ class OllamaLLMService(BaseLLMService):
     
     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": self.config.get("max_tokens", 2048),
+            "max_tokens": provider_config.get("max_tokens", 2048),
             "supports_streaming": True,
             "supports_functions": True,
             "provider": "ollama"
@@ -285,14 +318,15 @@ class OllamaLLMService(BaseLLMService):
             messages = self._prepare_messages(input_data)
             
             # Prepare request parameters for streaming
+            provider_config = self.get_provider_config()
             payload = {
                 "model": self.model_name,
                 "messages": messages,
                 "stream": True,  # Force streaming for astream
                 "options": {
-                    "temperature": self.config.get("temperature", 0.7),
-                    "top_p": self.config.get("top_p", 0.9),
-                    "num_predict": self.config.get("max_tokens", 2048)
+                    "temperature": provider_config.get("temperature", 0.7),
+                    "top_p": provider_config.get("top_p", 0.9),
+                    "num_predict": provider_config.get("max_tokens", 2048)
                 }
             }
             
@@ -320,7 +354,7 @@ class OllamaLLMService(BaseLLMService):
                 
                 # Track usage after streaming is complete (estimated)
                 full_content = "".join(content_chunks)
-                self._track_streaming_usage(messages, full_content)
+                await self._track_streaming_usage(messages, full_content)
                 
             except Exception as e:
                 logger.error(f"Error in streaming: {e}")

isa_model/inference/services/llm/openai_llm_service.py

@@ -7,19 +7,18 @@ from typing import Dict, Any, List, Union, AsyncGenerator, Optional, Callable
 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
+from ....core.types import ServiceType
 
 logger = logging.getLogger(__name__)
 
 class OpenAILLMService(BaseLLMService):
     """OpenAI LLM service implementation with unified invoke interface"""
     
-    def __init__(self, provider: 'BaseProvider', model_name: str = "gpt-4.1-nano"):
-        super().__init__(provider, model_name)
+    def __init__(self, model_name: str = "gpt-4o-mini", provider_name: str = "openai", **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:
@@ -28,7 +27,7 @@ class OpenAILLMService(BaseLLMService):
             
             self.client = AsyncOpenAI(
                 api_key=provider_config["api_key"],
-                base_url=provider_config.get("base_url", "https://api.openai.com/v1"),
+                base_url=provider_config.get("api_base_url", "https://api.openai.com/v1"),
                 organization=provider_config.get("organization")
             )
             
@@ -44,7 +43,7 @@ class OpenAILLMService(BaseLLMService):
     
     def _create_bound_copy(self) -> 'OpenAILLMService':
         """Create a copy of this service for tool binding"""
-        bound_service = OpenAILLMService(self.provider, self.model_name)
+        bound_service = OpenAILLMService(self.model_name, self.provider_name)
         bound_service._bound_tools = self._bound_tools.copy()
         return bound_service
     
@@ -82,11 +81,12 @@ class OpenAILLMService(BaseLLMService):
             messages = self._prepare_messages(input_data)
             
             # Prepare request kwargs
+            provider_config = self.get_provider_config()
             kwargs = {
                 "model": self.model_name,
                 "messages": messages,
-                "temperature": self.config.get("temperature", 0.7),
-                "max_tokens": self.config.get("max_tokens", 1024),
+                "temperature": provider_config.get("temperature", 0.7),
+                "max_tokens": provider_config.get("max_tokens", 1024),
                 "stream": True
             }
             
@@ -125,11 +125,12 @@ class OpenAILLMService(BaseLLMService):
             messages = self._prepare_messages(input_data)
             
             # Prepare request kwargs
+            provider_config = self.get_provider_config()
             kwargs = {
                 "model": self.model_name,
                 "messages": messages,
-                "temperature": self.config.get("temperature", 0.7),
-                "max_tokens": self.config.get("max_tokens", 1024)
+                "temperature": provider_config.get("temperature", 0.7),
+                "max_tokens": provider_config.get("max_tokens", 1024)
             }
             
             # Add tools if bound using adapter manager
@@ -155,7 +156,7 @@ class OpenAILLMService(BaseLLMService):
                 # Update usage tracking
                 if response.usage:
                     self._update_token_usage(response.usage)
-                    self._track_billing(response.usage)
+                    await self._track_billing(response.usage)
                 
                 # Handle tool calls if present - let adapter process the complete message
                 if message.tool_calls:
@@ -180,7 +181,14 @@ class OpenAILLMService(BaseLLMService):
         
         usage = MockUsage()
         self._update_token_usage(usage)
-        self._track_billing(usage)
+        # Fire and forget async tracking
+        import asyncio
+        try:
+            loop = asyncio.get_event_loop()
+            loop.create_task(self._track_billing(usage))
+        except:
+            # If no event loop, skip tracking
+            pass
     
     async def _stream_response(self, kwargs: Dict[str, Any]) -> AsyncGenerator[str, None]:
         """Handle streaming responses - DEPRECATED: Use astream() instead"""
@@ -214,16 +222,17 @@ class OpenAILLMService(BaseLLMService):
         self.total_token_usage["total_tokens"] += self.last_token_usage["total_tokens"]
         self.total_token_usage["requests_count"] += 1
     
-    def _track_billing(self, usage):
+    async def _track_billing(self, usage):
         """Track billing information"""
-        self._track_usage(
+        provider_config = self.get_provider_config()
+        await 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)
+                "temperature": provider_config.get("temperature", 0.7), 
+                "max_tokens": provider_config.get("max_tokens", 1024)
             }
         )
     
@@ -237,15 +246,57 @@ class OpenAILLMService(BaseLLMService):
     
     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": self.config.get("max_tokens", 1024),
+            "max_tokens": provider_config.get("max_tokens", 1024),
             "supports_streaming": True,
             "supports_functions": True,
             "provider": "openai"
         }
     
         
+    async def chat(
+        self,
+        input_data: Union[str, List[Dict[str, str]], Any],
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        Chat method that wraps ainvoke for compatibility with base class
+        
+        Args:
+            input_data: Input messages
+            max_tokens: Maximum tokens to generate
+            
+        Returns:
+            Dict containing chat response
+        """
+        try:
+            # Call ainvoke and get the response
+            response = await self.ainvoke(input_data)
+            
+            # Return in expected format
+            return {
+                "text": response if isinstance(response, str) else str(response),
+                "success": True,
+                "metadata": {
+                    "model": self.model_name,
+                    "provider": self.provider_name,
+                    "max_tokens": max_tokens or self.max_tokens
+                }
+            }
+        except Exception as e:
+            logger.error(f"Chat method failed: {e}")
+            return {
+                "text": "",
+                "success": False,
+                "error": str(e),
+                "metadata": {
+                    "model": self.model_name,
+                    "provider": self.provider_name
+                }
+            }
+    
     async def close(self):
         """Close the backend client"""
         await self.client.close()

isa_model/inference/services/llm/yyds_llm_service.py

@@ -5,19 +5,17 @@ from typing import Dict, Any, List, Union, AsyncGenerator
 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)
+    def __init__(self, provider_name: str, model_name: str = "claude-sonnet-4-20250514", **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:
@@ -26,7 +24,7 @@ class YydsLLMService(BaseLLMService):
             
             self.client = AsyncOpenAI(
                 api_key=provider_config["api_key"],
-                base_url=provider_config.get("base_url", "https://api.yyds.com/v1"),
+                base_url=provider_config.get("base_url") or provider_config.get("api_base_url", "https://api.yyds.com/v1"),
                 organization=provider_config.get("organization")
             )
             
@@ -42,7 +40,7 @@ class YydsLLMService(BaseLLMService):
     
     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 = YydsLLMService(self.provider_name, self.model_name)
         bound_service._bound_tools = self._bound_tools.copy()
         return bound_service
     
@@ -80,11 +78,12 @@ class YydsLLMService(BaseLLMService):
             messages = self._prepare_messages(input_data)
             
             # Prepare request kwargs
+            provider_config = self.get_provider_config()
             kwargs = {
                 "model": self.model_name,
                 "messages": messages,
-                "temperature": self.config.get("temperature", 0.7),
-                "max_tokens": self.config.get("max_tokens", 1024),
+                "temperature": provider_config.get("temperature", 0.7),
+                "max_tokens": provider_config.get("max_tokens", 1024),
                 "stream": True
             }
             
@@ -106,7 +105,7 @@ class YydsLLMService(BaseLLMService):
                 
                 # Track usage after streaming is complete
                 full_content = "".join(content_chunks)
-                self._track_streaming_usage(messages, full_content)
+                await self._track_streaming_usage(messages, full_content)
                 
             except Exception as e:
                 logger.error(f"Error in streaming: {e}")
@@ -123,11 +122,12 @@ class YydsLLMService(BaseLLMService):
             messages = self._prepare_messages(input_data)
             
             # Prepare request kwargs
+            provider_config = self.get_provider_config()
             kwargs = {
                 "model": self.model_name,
                 "messages": messages,
-                "temperature": self.config.get("temperature", 0.7),
-                "max_tokens": self.config.get("max_tokens", 1024)
+                "temperature": provider_config.get("temperature", 0.7),
+                "max_tokens": provider_config.get("max_tokens", 1024)
             }
             
             # Add tools if bound using adapter manager
@@ -153,7 +153,7 @@ class YydsLLMService(BaseLLMService):
                 # Update usage tracking
                 if response.usage:
                     self._update_token_usage(response.usage)
-                    self._track_billing(response.usage)
+                    await self._track_billing(response.usage)
                 
                 # Handle tool calls if present - let adapter process the complete message
                 if message.tool_calls:
@@ -167,7 +167,7 @@ class YydsLLMService(BaseLLMService):
             logger.error(f"Error in ainvoke: {e}")
             raise
     
-    def _track_streaming_usage(self, messages: List[Dict[str, str]], content: str):
+    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:
@@ -178,7 +178,7 @@ class YydsLLMService(BaseLLMService):
         
         usage = MockUsage()
         self._update_token_usage(usage)
-        self._track_billing(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"""
@@ -212,16 +212,16 @@ class YydsLLMService(BaseLLMService):
         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,
+    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": self.config.get("temperature", 0.7), 
-                "max_tokens": self.config.get("max_tokens", 1024)
+                "temperature": provider_config.get("temperature", 0.7), 
+                "max_tokens": provider_config.get("max_tokens", 1024)
             }
         )
     
@@ -235,9 +235,10 @@ class YydsLLMService(BaseLLMService):
     
     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": self.config.get("max_tokens", 1024),
+            "max_tokens": provider_config.get("max_tokens", 1024),
             "supports_streaming": True,
             "supports_functions": True,
             "provider": "yyds",

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")