isa-model 0.3.1__tar.gz → 0.3.2__tar.gz

{isa_model-0.3.1 → isa_model-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isa_model
-Version: 0.3.1
+Version: 0.3.2
 Summary: Unified AI model serving framework
 Author: isA_Model Contributors
 Classifier: Development Status :: 3 - Alpha

{isa_model-0.3.1 → isa_model-0.3.2}/isa_model/inference/services/llm/base_llm_service.py

@@ -90,80 +90,14 @@ class BaseLLMService(BaseService):
             # No event loop running, create a new one
             return asyncio.run(self.ainvoke(input_data))
     
-    # 保留旧的方法以保持向后兼容
-    def _convert_tools_to_schema(self, tools: List[Union[Dict[str, Any], Callable]]) -> List[Dict[str, Any]]:
-        """Convert tools to OpenAI function calling schema (deprecated, use adapter manager)"""
-        import asyncio
-        try:
-            loop = asyncio.get_event_loop()
-            schemas, _ = loop.run_until_complete(self.adapter_manager.convert_tools_to_schemas(tools))
-            return schemas
-        except RuntimeError:
-            schemas, _ = asyncio.run(self.adapter_manager.convert_tools_to_schemas(tools))
-            return schemas
-    
     def _has_bound_tools(self) -> bool:
         """Check if this service has bound tools"""
         return bool(self._bound_tools)
     
-    def _get_bound_tools(self) -> List[Dict[str, Any]]:
-        """Get the bound tools schema"""
+    def _get_bound_tools(self) -> List[Any]:
+        """Get the bound tools"""
         return self._bound_tools
     
-    def _convert_langchain_to_openai(self, messages: List[Any]) -> List[Dict[str, str]]:
-        """Convert LangChain message objects to OpenAI format"""
-        converted_messages = []
-        
-        for msg in messages:
-            # Handle different LangChain message types
-            if hasattr(msg, 'type') and hasattr(msg, 'content'):
-                # LangChain message object
-                msg_dict = {"content": str(msg.content)}
-                
-                # Map LangChain types to OpenAI roles
-                if msg.type == "system":
-                    msg_dict["role"] = "system"
-                elif msg.type == "human":
-                    msg_dict["role"] = "user"
-                elif msg.type == "ai":
-                    msg_dict["role"] = "assistant"
-                    # Handle tool calls if present
-                    if hasattr(msg, 'tool_calls') and msg.tool_calls:
-                        # Handle tool calls - need to store as separate key since it's not a string
-                        tool_calls = [
-                            {
-                                "id": tc.get("id", f"call_{i}"),
-                                "type": "function",
-                                "function": {
-                                    "name": tc["name"],
-                                    "arguments": tc.get("args", {}) if isinstance(tc.get("args"), dict) else tc.get("args", "{}")
-                                }
-                            } for i, tc in enumerate(msg.tool_calls)
-                        ]
-                        # Store tool_calls separately to avoid type issues
-                        msg_dict["tool_calls"] = tool_calls  # type: ignore
-                elif msg.type == "tool":
-                    msg_dict["role"] = "tool"
-                    if hasattr(msg, 'tool_call_id'):
-                        msg_dict["tool_call_id"] = msg.tool_call_id
-                elif msg.type == "function":  # Legacy function message
-                    msg_dict["role"] = "function"
-                    if hasattr(msg, 'name'):
-                        msg_dict["name"] = msg.name
-                else:
-                    msg_dict["role"] = "user"  # Default fallback
-                
-                converted_messages.append(msg_dict)
-                
-            elif isinstance(msg, dict):
-                # Already in OpenAI format
-                converted_messages.append(msg)
-            else:
-                # Fallback: treat as user message
-                converted_messages.append({"role": "user", "content": str(msg)})
-        
-        return converted_messages
-    
     @abstractmethod
     def get_token_usage(self) -> Dict[str, Any]:
         """Get cumulative token usage statistics"""

{isa_model-0.3.1 → isa_model-0.3.2}/isa_model/inference/services/llm/llm_adapter.py

@@ -100,18 +100,55 @@ class LangChainMessageAdapter:
         
         return converted_messages
     
-    def from_openai_format(self, response: str, original_input: Any) -> Any:
+    def from_openai_format(self, response: Union[str, Any], original_input: Any) -> Any:
         """从 OpenAI 格式转换回 LangChain 格式"""
         try:
             from langchain_core.messages import AIMessage
-            return AIMessage(content=response)
+            
+            # Handle response objects with tool_calls (OpenAI message objects)
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                # Convert OpenAI tool_calls to LangChain format
+                tool_calls = []
+                for tc in response.tool_calls:
+                    tool_call = {
+                        "name": tc.function.name,
+                        "args": json.loads(tc.function.arguments),
+                        "id": tc.id
+                    }
+                    tool_calls.append(tool_call)
+                
+                return AIMessage(
+                    content=response.content or "",
+                    tool_calls=tool_calls
+                )
+            else:
+                # Handle simple string response
+                content = response if isinstance(response, str) else getattr(response, 'content', str(response))
+                return AIMessage(content=content)
+                
         except ImportError:
             # 回退实现
             class SimpleAIMessage:
-                def __init__(self, content):
+                def __init__(self, content, tool_calls=None):
                     self.content = content
                     self.type = "ai"
-            return SimpleAIMessage(response)
+                    self.tool_calls = tool_calls or []
+            
+            # Handle response objects with tool_calls
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                tool_calls = []
+                for tc in response.tool_calls:
+                    tool_call = {
+                        "name": tc.function.name,
+                        "args": json.loads(tc.function.arguments),
+                        "id": tc.id
+                    }
+                    tool_calls.append(tool_call)
+                
+                return SimpleAIMessage(response.content or "", tool_calls)
+            else:
+                content = response if isinstance(response, str) else getattr(response, 'content', str(response))
+                return SimpleAIMessage(content)
 
 
 class LangChainToolAdapter:
@@ -293,9 +330,17 @@ class StandardMessageAdapter:
         else:
             return [{"role": "user", "content": str(input_data)}]
     
-    def from_openai_format(self, response: str, original_input: Any) -> Any:
+    def from_openai_format(self, response: Union[str, Any], original_input: Any) -> Any:
         """从 OpenAI 格式转换回原始格式"""
-        return response  # 默认返回字符串
+        # Handle response objects with tool_calls (preserve message object for compatibility)
+        if hasattr(response, 'tool_calls') and response.tool_calls:
+            # For standard format, we preserve the message object for tool_calls access
+            # This handles both OpenAI and Ollama message objects
+            return response
+        else:
+            # Handle simple string response
+            content = response if isinstance(response, str) else getattr(response, 'content', str(response))
+            return content
 
 
 # ============= 适配器管理器 =============

{isa_model-0.3.1 → isa_model-0.3.2}/isa_model/inference/services/llm/ollama_llm_service.py

@@ -8,7 +8,7 @@ from isa_model.inference.providers.base_provider import BaseProvider
 logger = logging.getLogger(__name__)
 
 class OllamaLLMService(BaseLLMService):
-    """Ollama LLM service with unified invoke interface"""
+    """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)
@@ -25,10 +25,6 @@ class OllamaLLMService(BaseLLMService):
         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}
         
-        # Tool binding attributes
-        self._bound_tools: List[Any] = []
-        self._tool_binding_kwargs: Dict[str, Any] = {}
-        self._tool_functions: Dict[str, Callable] = {}
         
         logger.info(f"Initialized OllamaLLMService with model {model_name} at {base_url}")
     
@@ -43,16 +39,13 @@ class OllamaLLMService(BaseLLMService):
         """Create a copy of this service for tool binding"""
         bound_service = OllamaLLMService(self.provider, self.model_name)
         bound_service._bound_tools = self._bound_tools.copy()
-        bound_service._tool_binding_kwargs = self._tool_binding_kwargs.copy()
-        bound_service._tool_functions = self._tool_functions.copy()
         return bound_service
     
-    def bind_tools(self, tools: List[Union[Dict[str, Any], Callable]], **kwargs) -> 'OllamaLLMService':
+    def bind_tools(self, tools: List[Any], **kwargs) -> 'OllamaLLMService':
         """Bind tools to this LLM service for function calling"""
         bound_service = self._create_bound_copy()
-        # 使用基类的适配器管理器方法
+        # Use base class method to bind tools
         bound_service._bound_tools = tools
-        bound_service._tool_binding_kwargs = kwargs
         
         return bound_service
     
@@ -73,7 +66,7 @@ class OllamaLLMService(BaseLLMService):
             # Ensure client is available
             self._ensure_client()
             
-            # Convert input to messages format
+            # Use adapter manager to prepare messages (consistent with OpenAI service)
             messages = self._prepare_messages(input_data)
             
             # Prepare request parameters
@@ -106,77 +99,36 @@ class OllamaLLMService(BaseLLMService):
             if "eval_count" in result:
                 self._update_token_usage(result)
             
-            # Handle tool calls if present
+            # Handle tool calls if present - let adapter process the complete message
             message = result["message"]
             if "tool_calls" in message and message["tool_calls"]:
-                return await self._handle_tool_calls(message, messages)
+                # Create message object similar to OpenAI format for adapter processing
+                message_obj = type('OllamaMessage', (), {
+                    'content': message.get("content", ""),
+                    'tool_calls': message["tool_calls"]
+                })()
+                # Pass the complete message object to adapter for proper tool_calls handling
+                return self._format_response(message_obj, input_data)
             
             # Return appropriate format based on input type
-            return self._format_response(message["content"], input_data)
+            return self._format_response(message.get("content", ""), input_data)
             
         except httpx.RequestError as e:
             logger.error(f"HTTP request error in ainvoke: {e}")
             raise
         except Exception as e:
-            logger.error(f"Error in ainvoke: {e}")
+            logger.error(f"Error in chat completion: {e}")
             raise
     
     def _prepare_messages(self, input_data: Union[str, List[Dict[str, str]], Any]) -> List[Dict[str, str]]:
-        """Convert various input formats to Ollama messages format (same as OpenAI)"""
-        if isinstance(input_data, str):
-            # Simple string prompt
-            return [{"role": "user", "content": input_data}]
-        
-        elif isinstance(input_data, list):
-            if not input_data:
-                raise ValueError("Empty message list provided")
-            
-            # Check if it's LangChain messages or standard messages
-            first_msg = input_data[0]
-            if hasattr(first_msg, 'content') and hasattr(first_msg, 'type'):
-                # LangChain message objects - use base class method
-                return self._convert_langchain_to_openai(input_data)
-            elif isinstance(first_msg, dict):
-                # Standard message dictionaries
-                return input_data
-            else:
-                # List of strings or other formats
-                messages = []
-                for i, msg in enumerate(input_data):
-                    if isinstance(msg, str):
-                        role = "user" if i % 2 == 0 else "assistant"
-                        messages.append({"role": role, "content": msg})
-                    elif isinstance(msg, dict):
-                        messages.append(msg)
-                    else:
-                        messages.append({"role": "user", "content": str(msg)})
-                return messages
-        
-        else:
-            # Handle single LangChain message objects or other objects
-            if hasattr(input_data, 'content') and hasattr(input_data, 'type'):
-                return self._convert_langchain_to_openai([input_data])
-            else:
-                return [{"role": "user", "content": str(input_data)}]
+        """Use adapter manager to convert messages (consistent with OpenAI service)"""
+        return self.adapter_manager.convert_messages(input_data)
+    
+    
+    def _format_response(self, response: Union[str, Any], original_input: Any) -> Union[str, Any]:
+        """Use adapter manager to format response (consistent with OpenAI service)"""
+        return self.adapter_manager.format_response(response, original_input)
     
-    def _format_response(self, content: str, original_input: Any) -> Union[str, Any]:
-        """Format response based on original input type"""
-        # For LangGraph compatibility, return AIMessage object if needed
-        if hasattr(original_input, 'type') or (isinstance(original_input, list) and 
-                                               original_input and hasattr(original_input[0], 'type')):
-            try:
-                from langchain_core.messages import AIMessage
-                return AIMessage(content=content)
-            except ImportError:
-                # Fallback to simple object
-                class SimpleAIMessage:
-                    def __init__(self, content):
-                        self.content = content
-                        self.type = "ai"
-                return SimpleAIMessage(content)
-        
-        # Default to string
-        return content
     
     async def _stream_response(self, payload: Dict[str, Any]) -> AsyncGenerator[str, None]:
         """Handle streaming responses"""
@@ -270,13 +222,6 @@ class OllamaLLMService(BaseLLMService):
             "provider": "ollama"
         }
     
-    def _has_bound_tools(self) -> bool:
-        """Check if this service has bound tools"""
-        return bool(self._bound_tools)
-    
-    def _get_bound_tools(self) -> List[Any]:
-        """Get the bound tools schema"""
-        return self._bound_tools
         
     async def close(self):
         """Close the HTTP client"""
@@ -285,4 +230,4 @@ class OllamaLLMService(BaseLLMService):
                 if not self.client.is_closed:
                     await self.client.aclose()
             except Exception as e:
-                logger.warning(f"Error closing Ollama client: {e}") 
+                logger.warning(f"Error closing Ollama client: {e}")

{isa_model-0.3.1 → isa_model-0.3.2}/isa_model/inference/services/llm/openai_llm_service.py

@@ -41,17 +41,11 @@ class OpenAILLMService(BaseLLMService):
         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}
         
-        # Tool binding attributes
-        self._bound_tools: List[Dict[str, Any]] = []
-        self._tool_binding_kwargs: Dict[str, Any] = {}
-        self._tool_functions: Dict[str, Callable] = {}
     
     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._bound_tools = self._bound_tools.copy()
-        bound_service._tool_binding_kwargs = self._tool_binding_kwargs.copy()
-        bound_service._tool_functions = self._tool_functions.copy()
         return bound_service
     
     def bind_tools(self, tools: List[Any], **kwargs) -> 'OpenAILLMService':
@@ -68,7 +62,7 @@ class OpenAILLMService(BaseLLMService):
         # Create a copy of this service
         bound_service = self._create_bound_copy()
         
-        # Use the adapter manager to handle tools
+        # Use base class method to bind tools
         bound_service._bound_tools = tools
         
         return bound_service
@@ -123,10 +117,10 @@ class OpenAILLMService(BaseLLMService):
                     self._update_token_usage(response.usage)
                     self._track_billing(response.usage)
                 
-                # Handle tool calls if present
+                # Handle tool calls if present - let adapter process the complete message
                 if message.tool_calls:
-                    final_content = await self._handle_tool_calls(message, messages)
-                    return self._format_response(final_content, input_data)
+                    # 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)
@@ -135,13 +129,6 @@ class OpenAILLMService(BaseLLMService):
             logger.error(f"Error in ainvoke: {e}")
             raise
     
-    def _prepare_messages(self, input_data: Union[str, List[Dict[str, str]], Any]) -> List[Dict[str, str]]:
-        """使用适配器管理器转换消息格式（覆盖基类方法以保持兼容性）"""
-        return self.adapter_manager.convert_messages(input_data)
-    
-    def _format_response(self, content: str, original_input: Any) -> Union[str, Any]:
-        """使用适配器管理器格式化响应（覆盖基类方法以保持兼容性）"""
-        return self.adapter_manager.format_response(content, original_input)
     
     async def _stream_response(self, kwargs: Dict[str, Any]) -> AsyncGenerator[str, None]:
         """Handle streaming responses"""
@@ -160,63 +147,6 @@ class OpenAILLMService(BaseLLMService):
         
         return stream_generator()
     
-    async def _handle_tool_calls(self, assistant_message, original_messages: List[Dict[str, str]]) -> str:
-        """Handle tool calls from the assistant using adapter manager"""
-        # Add assistant message with tool calls to conversation
-        messages = original_messages + [{
-            "role": "assistant", 
-            "content": assistant_message.content or "",
-            "tool_calls": [
-                {
-                    "id": tc.id,
-                    "type": tc.type,
-                    "function": {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments
-                    }
-                } for tc in assistant_message.tool_calls
-            ]
-        }]
-        
-        # Execute each tool call using adapter manager
-        for tool_call in assistant_message.tool_calls:
-            function_name = tool_call.function.name
-            arguments = json.loads(tool_call.function.arguments)
-            
-            try:
-                # Use adapter manager to execute tool
-                result = await self._execute_tool_call(function_name, arguments)
-                
-                # Add tool result to messages
-                messages.append({
-                    "role": "tool",
-                    "content": str(result),
-                    "tool_call_id": tool_call.id
-                })
-                
-            except Exception as e:
-                logger.error(f"Error executing tool {function_name}: {e}")
-                messages.append({
-                    "role": "tool",
-                    "content": f"Error executing {function_name}: {str(e)}",
-                    "tool_call_id": tool_call.id
-                })
-        
-        # Get final response from the model
-        try:
-            kwargs = {
-                "model": self.model_name,
-                "messages": messages,
-                "temperature": self.config.get("temperature", 0.7),
-                "max_tokens": self.config.get("max_tokens", 1024)
-            }
-            
-            response = await self.client.chat.completions.create(**kwargs)
-            return response.choices[0].message.content or ""
-            
-        except Exception as e:
-            logger.error(f"Error getting final response after tool calls: {e}")
-            raise
     
     def _update_token_usage(self, usage):
         """Update token usage statistics"""
@@ -263,13 +193,6 @@ class OpenAILLMService(BaseLLMService):
             "provider": "openai"
         }
     
-    def _has_bound_tools(self) -> bool:
-        """Check if this service has bound tools"""
-        return bool(self._bound_tools)
-    
-    def _get_bound_tools(self) -> List[Dict[str, Any]]:
-        """Get the bound tools schema"""
-        return self._bound_tools
         
     async def close(self):
         """Close the backend client"""

{isa_model-0.3.1 → isa_model-0.3.2}/isa_model.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isa_model
-Version: 0.3.1
+Version: 0.3.2
 Summary: Unified AI model serving framework
 Author: isA_Model Contributors
 Classifier: Development Status :: 3 - Alpha

{isa_model-0.3.1 → isa_model-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "isa_model"
-version = "0.3.1"
+version = "0.3.2"
 description = "Unified AI model serving framework"
 authors = [{name = "isA_Model Contributors"}]
 readme = "README.md"