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

isa_model/inference/services/llm/base_llm_service.py

@@ -1,21 +1,332 @@
 from abc import ABC, abstractmethod
 from typing import Dict, Any, List, Union, Optional, AsyncGenerator, Callable
+import logging
+
 from isa_model.inference.services.base_service import BaseService
-from isa_model.inference.services.llm.llm_adapter import AdapterManager
+from isa_model.inference.services.llm.helpers.llm_adapter import AdapterManager
+
+logger = logging.getLogger(__name__)
 
 class BaseLLMService(BaseService):
-    """Base class for Large Language Model services with unified invoke interface"""
+    """Base class for Large Language Model services with unified task dispatch"""
     
-    def __init__(self, provider, model_name: str):
-        super().__init__(provider, model_name)
-        self._bound_tools: List[Any] = []  # 改为存储原始工具对象
-        self._tool_mappings: Dict[str, tuple] = {}  # 工具名到(工具, 适配器)的映射
+    def __init__(self, provider_name: str, model_name: str, **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
+        self._bound_tools: List[Any] = []
+        self._tool_mappings: Dict[str, tuple] = {}
         
         # 初始化适配器管理器
         self.adapter_manager = AdapterManager()
         
-        # Get streaming config from provider config
-        self.streaming = self.config.get("streaming", False)
+        # Get config from provider
+        provider_config = self.get_provider_config()
+        self.streaming = provider_config.get("streaming", False)
+        self.max_tokens = provider_config.get("max_tokens", 4096)
+        self.temperature = provider_config.get("temperature", 0.7)
+    
+    async def invoke(
+        self, 
+        input_data: Union[str, List[Dict[str, str]], Any],
+        task: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        统一的任务分发方法 - Base类提供通用实现
+        
+        Args:
+            input_data: 输入数据，可以是:
+                - str: 简单文本提示
+                - list: 消息历史 [{"role": "user", "content": "hello"}]
+                - Any: LangChain 消息对象或其他格式
+            task: 任务类型，支持多种LLM任务
+            **kwargs: 任务特定的附加参数
+            
+        Returns:
+            Dict containing task results
+        """
+        task = task or "chat"
+        
+        # ==================== 对话类任务 ====================
+        if task == "chat":
+            return await self.chat(input_data, kwargs.get("max_tokens", self.max_tokens))
+        elif task == "complete":
+            return await self.complete_text(input_data, kwargs.get("max_tokens", self.max_tokens))
+        elif task == "instruct":
+            return await self.instruct(input_data, kwargs.get("instruction"), kwargs.get("max_tokens", self.max_tokens))
+        
+        # ==================== 文本生成类任务 ====================
+        elif task == "generate":
+            return await self.generate_text(input_data, kwargs.get("max_tokens", self.max_tokens))
+        elif task == "rewrite":
+            return await self.rewrite_text(input_data, kwargs.get("style"), kwargs.get("tone"))
+        elif task == "summarize":
+            return await self.summarize_text(input_data, kwargs.get("max_length"), kwargs.get("style"))
+        elif task == "translate":
+            return await self.translate_text(input_data, kwargs.get("target_language"), kwargs.get("source_language"))
+        
+        # ==================== 分析类任务 ====================
+        elif task == "analyze":
+            return await self.analyze_text(input_data, kwargs.get("analysis_type"))
+        elif task == "classify":
+            return await self.classify_text(input_data, kwargs.get("categories"))
+        elif task == "extract":
+            return await self.extract_information(input_data, kwargs.get("extract_type"))
+        elif task == "sentiment":
+            return await self.analyze_sentiment(input_data)
+        
+        # ==================== 编程类任务 ====================
+        elif task == "code":
+            return await self.generate_code(input_data, kwargs.get("language"), kwargs.get("style"))
+        elif task == "explain_code":
+            return await self.explain_code(input_data, kwargs.get("language"))
+        elif task == "debug_code":
+            return await self.debug_code(input_data, kwargs.get("language"))
+        elif task == "refactor_code":
+            return await self.refactor_code(input_data, kwargs.get("language"), kwargs.get("improvements"))
+        
+        # ==================== 推理类任务 ====================
+        elif task == "reason":
+            return await self.reason_about(input_data, kwargs.get("reasoning_type"))
+        elif task == "solve":
+            return await self.solve_problem(input_data, kwargs.get("problem_type"))
+        elif task == "plan":
+            return await self.create_plan(input_data, kwargs.get("plan_type"))
+        
+        # ==================== 工具调用类任务 ====================
+        elif task == "tool_call":
+            return await self.call_tools(input_data, kwargs.get("available_tools"))
+        elif task == "function_call":
+            return await self.call_function(input_data, kwargs.get("function_name"), kwargs.get("parameters"))
+        
+        else:
+            raise NotImplementedError(f"{self.__class__.__name__} does not support task: {task}")
+    
+    # ==================== 对话类方法 ====================
+    
+    async def chat(
+        self,
+        input_data: Union[str, List[Dict[str, str]], Any],
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        对话聊天 - Provider必须实现
+        
+        Args:
+            input_data: 输入消息
+            max_tokens: 最大生成token数
+            
+        Returns:
+            Dict containing chat response
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support chat task")
+    
+    # ==================== 文本生成类方法 ====================
+    
+    async def complete_text(
+        self,
+        input_data: Union[str, Any],
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        文本补全 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support complete_text task")
+    
+    async def instruct(
+        self,
+        input_data: Union[str, Any],
+        instruction: Optional[str] = None,
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        指令跟随 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support instruct task")
+    
+    async def generate_text(
+        self,
+        input_data: Union[str, Any],
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        通用文本生成 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support generate_text task")
+    
+    async def rewrite_text(
+        self,
+        input_data: Union[str, Any],
+        style: Optional[str] = None,
+        tone: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        文本重写 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support rewrite_text task")
+    
+    async def summarize_text(
+        self,
+        input_data: Union[str, Any],
+        max_length: Optional[int] = None,
+        style: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        文本摘要 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support summarize_text task")
+    
+    async def translate_text(
+        self,
+        input_data: Union[str, Any],
+        target_language: str,
+        source_language: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        文本翻译 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support translate_text task")
+    
+    # ==================== 分析类方法 ====================
+    
+    async def analyze_text(
+        self,
+        input_data: Union[str, Any],
+        analysis_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        文本分析 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_text task")
+    
+    async def classify_text(
+        self,
+        input_data: Union[str, Any],
+        categories: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        文本分类 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support classify_text task")
+    
+    async def extract_information(
+        self,
+        input_data: Union[str, Any],
+        extract_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        信息提取 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support extract_information task")
+    
+    async def analyze_sentiment(
+        self,
+        input_data: Union[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        情感分析 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_sentiment task")
+    
+    # ==================== 编程类方法 ====================
+    
+    async def generate_code(
+        self,
+        input_data: Union[str, Any],
+        language: Optional[str] = None,
+        style: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        代码生成 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support generate_code task")
+    
+    async def explain_code(
+        self,
+        input_data: Union[str, Any],
+        language: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        代码解释 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support explain_code task")
+    
+    async def debug_code(
+        self,
+        input_data: Union[str, Any],
+        language: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        代码调试 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support debug_code task")
+    
+    async def refactor_code(
+        self,
+        input_data: Union[str, Any],
+        language: Optional[str] = None,
+        improvements: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        代码重构 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support refactor_code task")
+    
+    # ==================== 推理类方法 ====================
+    
+    async def reason_about(
+        self,
+        input_data: Union[str, Any],
+        reasoning_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        推理分析 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support reason_about task")
+    
+    async def solve_problem(
+        self,
+        input_data: Union[str, Any],
+        problem_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        问题求解 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support solve_problem task")
+    
+    async def create_plan(
+        self,
+        input_data: Union[str, Any],
+        plan_type: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        计划制定 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support create_plan task")
+    
+    # ==================== 工具调用类方法 ====================
+    
+    async def call_tools(
+        self,
+        input_data: Union[str, Any],
+        available_tools: Optional[List[Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        工具调用 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support call_tools task")
+    
+    async def call_function(
+        self,
+        input_data: Union[str, Any],
+        function_name: str,
+        parameters: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        函数调用 - Provider可选实现
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support call_function task")
+    
+    # ==================== 工具绑定和管理 ====================
     
     def bind_tools(self, tools: List[Any], **kwargs) -> 'BaseLLMService':
         """
@@ -99,28 +410,6 @@ class BaseLLMService(BaseService):
         """
         return self.astream(input_data)
     
-    def invoke(self, input_data: Union[str, List[Dict[str, str]], Any]) -> Union[str, Any]:
-        """
-        Synchronous wrapper for ainvoke
-        
-        Args:
-            input_data: Same as ainvoke
-            
-        Returns:
-            Model response
-        """
-        import asyncio
-        try:
-            # Try to get current event loop
-            loop = asyncio.get_running_loop()
-            # If we're in an event loop, create a new thread
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, self.ainvoke(input_data))
-                return future.result()
-        except RuntimeError:
-            # No event loop running, create a new one
-            return asyncio.run(self.ainvoke(input_data))
     
     def _has_bound_tools(self) -> bool:
         """Check if this service has bound tools"""
@@ -154,19 +443,182 @@ class BaseLLMService(BaseService):
         """Get last request usage with cost information"""
         usage = self.get_last_token_usage()
         
-        # Calculate cost using provider
-        if hasattr(self.provider, 'calculate_cost'):
-            cost = getattr(self.provider, 'calculate_cost')(
-                self.model_name,
-                usage["prompt_tokens"],
-                usage["completion_tokens"]
-            )
-        else:
-            cost = 0.0
+        # Calculate cost using centralized pricing manager
+        cost = self.model_manager.calculate_cost(
+            provider=self.provider_name,
+            model_name=self.model_name,
+            input_tokens=usage.get("prompt_tokens", 0),
+            output_tokens=usage.get("completion_tokens", 0)
+        )
         
         return {
             **usage,
             "cost_usd": cost,
             "model": self.model_name,
-            "provider": getattr(self.provider, 'name', 'unknown')
+            "provider": self.provider_name
+        }
+    
+    async def _track_llm_usage(
+        self,
+        operation: str,
+        input_tokens: Optional[int] = None,
+        output_tokens: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> float:
+        """
+        Track LLM usage using the unified BaseService billing system
+        
+        Returns:
+            Cost in USD
+        """
+        from isa_model.core.types import ServiceType
+        
+        await self._track_usage(
+            service_type=ServiceType.LLM,
+            operation=operation,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            metadata=metadata
+        )
+        
+        # Return calculated cost
+        if input_tokens is not None and output_tokens is not None:
+            return self.model_manager.calculate_cost(
+                provider=self.provider_name,
+                model_name=self.model_name,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens
+            )
+        return 0.0
+    
+    # ==================== METADATA AND UTILITY METHODS ====================
+    
+    def get_supported_tasks(self) -> List[str]:
+        """
+        获取provider支持的任务列表
+        
+        Returns:
+            List of supported task names
+        """
+        supported = []
+        
+        # 检查各类任务支持情况
+        method_task_map = {
+            # 对话类
+            'chat': 'chat',
+            'complete_text': 'complete',
+            'instruct': 'instruct',
+            # 文本生成类
+            'generate_text': 'generate',
+            'rewrite_text': 'rewrite',
+            'summarize_text': 'summarize',
+            'translate_text': 'translate',
+            # 分析类
+            'analyze_text': 'analyze',
+            'classify_text': 'classify',
+            'extract_information': 'extract',
+            'analyze_sentiment': 'sentiment',
+            # 编程类
+            'generate_code': 'code',
+            'explain_code': 'explain_code',
+            'debug_code': 'debug_code',
+            'refactor_code': 'refactor_code',
+            # 推理类
+            'reason_about': 'reason',
+            'solve_problem': 'solve',
+            'create_plan': 'plan',
+            # 工具调用类
+            'call_tools': 'tool_call',
+            'call_function': 'function_call'
+        }
+        
+        for method_name, task_name in method_task_map.items():
+            if hasattr(self, method_name):
+                # 检查是否是默认实现还是provider自己的实现
+                try:
+                    import inspect
+                    source = inspect.getsource(getattr(self, method_name))
+                    if 'NotImplementedError' not in source:
+                        supported.append(task_name)
+                except:
+                    # 如果无法检查源码，假设支持
+                    supported.append(task_name)
+                    
+        return supported
+    
+    def get_supported_languages(self) -> List[str]:
+        """
+        获取支持的编程语言列表 - Provider应该实现
+        
+        Returns:
+            List of supported programming languages
+        """
+        return [
+            'python', 'javascript', 'typescript', 'java', 'c++', 'c#', 
+            'go', 'rust', 'php', 'ruby', 'swift', 'kotlin', 'scala',
+            'r', 'matlab', 'sql', 'html', 'css', 'bash', 'powershell'
+        ]  # 通用语言支持
+    
+    def get_max_context_length(self) -> int:
+        """
+        获取最大上下文长度 - Provider应该实现
+        
+        Returns:
+            Maximum context length in tokens
+        """
+        return self.max_tokens or 4096  # 默认值
+    
+    def get_supported_formats(self) -> List[str]:
+        """
+        获取支持的输入格式 - Provider应该实现
+        
+        Returns:
+            List of supported input formats
+        """
+        return ['text', 'json', 'markdown', 'code']  # 通用格式
+    
+    def supports_streaming(self) -> bool:
+        """
+        检查是否支持流式输出
+        
+        Returns:
+            True if streaming is supported
+        """
+        return self.streaming
+    
+    def supports_function_calling(self) -> bool:
+        """
+        检查是否支持函数调用
+        
+        Returns:
+            True if function calling is supported
+        """
+        return hasattr(self, 'call_tools') or hasattr(self, 'call_function')
+    
+    def get_temperature_range(self) -> Dict[str, float]:
+        """
+        获取温度参数范围
+        
+        Returns:
+            Dict with min and max temperature values
+        """
+        return {"min": 0.0, "max": 2.0, "default": self.temperature}
+    
+    def get_provider_info(self) -> Dict[str, Any]:
+        """
+        获取provider信息
+        
+        Returns:
+            Dict containing provider information
+        """
+        return {
+            "provider": self.provider_name,
+            "model": self.model_name,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "streaming": self.streaming,
+            "supports_tools": self.supports_function_calling(),
+            "supported_tasks": self.get_supported_tasks(),
+            "supported_languages": self.get_supported_languages(),
+            "max_context_length": self.get_max_context_length()
         }