praisonaiagents 0.0.111__py3-none-any.whl → 0.0.113__py3-none-any.whl

praisonaiagents/llm/llm.py

@@ -311,6 +311,118 @@ class LLM:
         # This ensures we make a single non-streaming call rather than risk
         # missing tool calls or making duplicate calls
         return False
+    
+    def _build_messages(self, prompt, system_prompt=None, chat_history=None, output_json=None, output_pydantic=None):
+        """Build messages list for LLM completion. Works for both sync and async.
+        
+        Args:
+            prompt: The user prompt (str or list)
+            system_prompt: Optional system prompt
+            chat_history: Optional list of previous messages
+            output_json: Optional Pydantic model for JSON output
+            output_pydantic: Optional Pydantic model for JSON output (alias)
+            
+        Returns:
+            tuple: (messages list, original prompt)
+        """
+        messages = []
+        
+        # Handle system prompt
+        if system_prompt:
+            # Append JSON schema if needed
+            if output_json:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
+            elif output_pydantic:
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
+            
+            # Skip system messages for legacy o1 models as they don't support them
+            if not self._needs_system_message_skip():
+                messages.append({"role": "system", "content": system_prompt})
+        
+        # Add chat history if provided
+        if chat_history:
+            messages.extend(chat_history)
+        
+        # Handle prompt modifications for JSON output
+        original_prompt = prompt
+        if output_json or output_pydantic:
+            if isinstance(prompt, str):
+                prompt = prompt + "\nReturn ONLY a valid JSON object. No other text or explanation."
+            elif isinstance(prompt, list):
+                # Create a copy to avoid modifying the original
+                prompt = prompt.copy()
+                for item in prompt:
+                    if item.get("type") == "text":
+                        item["text"] = item["text"] + "\nReturn ONLY a valid JSON object. No other text or explanation."
+                        break
+        
+        # Add prompt to messages
+        if isinstance(prompt, list):
+            messages.append({"role": "user", "content": prompt})
+        else:
+            messages.append({"role": "user", "content": prompt})
+        
+        return messages, original_prompt
+
+    def _format_tools_for_litellm(self, tools: Optional[List[Any]]) -> Optional[List[Dict]]:
+        """Format tools for LiteLLM - handles all tool formats.
+        
+        Supports:
+        - Pre-formatted OpenAI tools (dicts with type='function')
+        - Lists of pre-formatted tools
+        - Callable functions
+        - String function names
+        
+        Args:
+            tools: List of tools in various formats
+            
+        Returns:
+            List of formatted tools or None
+        """
+        if not tools:
+            return None
+            
+        formatted_tools = []
+        for tool in tools:
+            # Check if the tool is already in OpenAI format (e.g. from MCP.to_openai_tool())
+            if isinstance(tool, dict) and 'type' in tool and tool['type'] == 'function':
+                # Validate nested dictionary structure before accessing
+                if 'function' in tool and isinstance(tool['function'], dict) and 'name' in tool['function']:
+                    logging.debug(f"Using pre-formatted OpenAI tool: {tool['function']['name']}")
+                    formatted_tools.append(tool)
+                else:
+                    logging.debug(f"Skipping malformed OpenAI tool: missing function or name")
+            # Handle lists of tools (e.g. from MCP.to_openai_tool())
+            elif isinstance(tool, list):
+                for subtool in tool:
+                    if isinstance(subtool, dict) and 'type' in subtool and subtool['type'] == 'function':
+                        # Validate nested dictionary structure before accessing
+                        if 'function' in subtool and isinstance(subtool['function'], dict) and 'name' in subtool['function']:
+                            logging.debug(f"Using pre-formatted OpenAI tool from list: {subtool['function']['name']}")
+                            formatted_tools.append(subtool)
+                        else:
+                            logging.debug(f"Skipping malformed OpenAI tool in list: missing function or name")
+            elif callable(tool):
+                tool_def = self._generate_tool_definition(tool)
+                if tool_def:
+                    formatted_tools.append(tool_def)
+            elif isinstance(tool, str):
+                tool_def = self._generate_tool_definition(tool)
+                if tool_def:
+                    formatted_tools.append(tool_def)
+            else:
+                logging.debug(f"Skipping tool of unsupported type: {type(tool)}")
+                
+        # Validate JSON serialization before returning
+        if formatted_tools:
+            try:
+                import json
+                json.dumps(formatted_tools)  # Validate serialization
+            except (TypeError, ValueError) as e:
+                logging.error(f"Tools are not JSON serializable: {e}")
+                return None
+                
+        return formatted_tools if formatted_tools else None
 
     def get_response(
         self,
@@ -393,64 +505,16 @@ class LLM:
             litellm.set_verbose = False
             
             # Format tools if provided
-            formatted_tools = None
-            if tools:
-                formatted_tools = []
-                for tool in tools:
-                    # Check if the tool is already in OpenAI format (e.g. from MCP.to_openai_tool())
-                    if isinstance(tool, dict) and 'type' in tool and tool['type'] == 'function':
-                        logging.debug(f"Using pre-formatted OpenAI tool: {tool['function']['name']}")
-                        formatted_tools.append(tool)
-                    # Handle lists of tools (e.g. from MCP.to_openai_tool())
-                    elif isinstance(tool, list):
-                        for subtool in tool:
-                            if isinstance(subtool, dict) and 'type' in subtool and subtool['type'] == 'function':
-                                logging.debug(f"Using pre-formatted OpenAI tool from list: {subtool['function']['name']}")
-                                formatted_tools.append(subtool)
-                    elif callable(tool):
-                        tool_def = self._generate_tool_definition(tool.__name__)
-                        if tool_def:
-                            formatted_tools.append(tool_def)
-                    elif isinstance(tool, str):
-                        tool_def = self._generate_tool_definition(tool)
-                        if tool_def:
-                            formatted_tools.append(tool_def)
-                    else:
-                        logging.debug(f"Skipping tool of unsupported type: {type(tool)}")
-                        
-                if not formatted_tools:
-                    formatted_tools = None
-            
-            # Build messages list
-            messages = []
-            if system_prompt:
-                if output_json:
-                    system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
-                elif output_pydantic:
-                    system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-                # Skip system messages for legacy o1 models as they don't support them
-                if not self._needs_system_message_skip():
-                    messages.append({"role": "system", "content": system_prompt})
+            formatted_tools = self._format_tools_for_litellm(tools)
             
-            if chat_history:
-                messages.extend(chat_history)
-
-            # Handle prompt modifications for JSON output
-            original_prompt = prompt
-            if output_json or output_pydantic:
-                if isinstance(prompt, str):
-                    prompt += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                elif isinstance(prompt, list):
-                    for item in prompt:
-                        if item["type"] == "text":
-                            item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                            break
-
-            # Add prompt to messages
-            if isinstance(prompt, list):
-                messages.append({"role": "user", "content": prompt})
-            else:
-                messages.append({"role": "user", "content": prompt})
+            # Build messages list using shared helper
+            messages, original_prompt = self._build_messages(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                chat_history=chat_history,
+                output_json=output_json,
+                output_pydantic=output_pydantic
+            )
 
             start_time = time.time()
             reflection_count = 0
@@ -1160,108 +1224,20 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             reasoning_steps = kwargs.pop('reasoning_steps', self.reasoning_steps)
             litellm.set_verbose = False
 
-            # Build messages list
-            messages = []
-            if system_prompt:
-                if output_json:
-                    system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
-                elif output_pydantic:
-                    system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-                # Skip system messages for legacy o1 models as they don't support them
-                if not self._needs_system_message_skip():
-                    messages.append({"role": "system", "content": system_prompt})
-            
-            if chat_history:
-                messages.extend(chat_history)
-
-            # Handle prompt modifications for JSON output
-            original_prompt = prompt
-            if output_json or output_pydantic:
-                if isinstance(prompt, str):
-                    prompt += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                elif isinstance(prompt, list):
-                    for item in prompt:
-                        if item["type"] == "text":
-                            item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                            break
-
-            # Add prompt to messages
-            if isinstance(prompt, list):
-                messages.append({"role": "user", "content": prompt})
-            else:
-                messages.append({"role": "user", "content": prompt})
+            # Build messages list using shared helper
+            messages, original_prompt = self._build_messages(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                chat_history=chat_history,
+                output_json=output_json,
+                output_pydantic=output_pydantic
+            )
 
             start_time = time.time()
             reflection_count = 0
 
-            # Format tools for LiteLLM
-            formatted_tools = None
-            if tools:
-                logging.debug(f"Starting tool formatting for {len(tools)} tools")
-                formatted_tools = []
-                for tool in tools:
-                    logging.debug(f"Processing tool: {tool.__name__ if hasattr(tool, '__name__') else str(tool)}")
-                    if hasattr(tool, '__name__'):
-                        tool_name = tool.__name__
-                        tool_doc = tool.__doc__ or "No description available"
-                        # Get function signature
-                        import inspect
-                        sig = inspect.signature(tool)
-                        logging.debug(f"Tool signature: {sig}")
-                        params = {}
-                        required = []
-                        for name, param in sig.parameters.items():
-                            logging.debug(f"Processing parameter: {name} with annotation: {param.annotation}")
-                            param_type = "string"
-                            if param.annotation != inspect.Parameter.empty:
-                                if param.annotation == int:
-                                    param_type = "integer"
-                                elif param.annotation == float:
-                                    param_type = "number"
-                                elif param.annotation == bool:
-                                    param_type = "boolean"
-                                elif param.annotation == Dict:
-                                    param_type = "object"
-                                elif param.annotation == List:
-                                    param_type = "array"
-                                elif hasattr(param.annotation, "__name__"):
-                                    param_type = param.annotation.__name__.lower()
-                            params[name] = {"type": param_type}
-                            if param.default == inspect.Parameter.empty:
-                                required.append(name)
-                        
-                        logging.debug(f"Generated parameters: {params}")
-                        logging.debug(f"Required parameters: {required}")
-                        
-                        tool_def = {
-                            "type": "function",
-                            "function": {
-                                "name": tool_name,
-                                "description": tool_doc,
-                                "parameters": {
-                                    "type": "object",
-                                    "properties": params,
-                                    "required": required
-                                }
-                            }
-                        }
-                        # Ensure tool definition is JSON serializable
-                        try:
-                            json.dumps(tool_def)  # Test serialization
-                            logging.debug(f"Generated tool definition: {tool_def}")
-                            formatted_tools.append(tool_def)
-                        except TypeError as e:
-                            logging.error(f"Tool definition not JSON serializable: {e}")
-                            continue
-
-            # Validate final tools list
-            if formatted_tools:
-                try:
-                    json.dumps(formatted_tools)  # Final serialization check
-                    logging.debug(f"Final formatted tools: {json.dumps(formatted_tools, indent=2)}")
-                except TypeError as e:
-                    logging.error(f"Final tools list not JSON serializable: {e}")
-                    formatted_tools = None
+            # Format tools for LiteLLM using the shared helper
+            formatted_tools = self._format_tools_for_litellm(tools)
 
             response_text = ""
             if reasoning_steps:
@@ -1901,18 +1877,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 }
                 logger.debug(f"Response method configuration: {json.dumps(debug_info, indent=2, default=str)}")
             
-            # Build messages list
-            messages = []
-            if system_prompt:
-                # Skip system messages for legacy o1 models as they don't support them
-                if not self._needs_system_message_skip():
-                    messages.append({"role": "system", "content": system_prompt})
-            
-            # Add prompt to messages
-            if isinstance(prompt, list):
-                messages.append({"role": "user", "content": prompt})
-            else:
-                messages.append({"role": "user", "content": prompt})
+            # Build messages list using shared helper (simplified version without JSON output)
+            messages, _ = self._build_messages(
+                prompt=prompt,
+                system_prompt=system_prompt
+            )
 
             # Get response from LiteLLM
             if stream:
@@ -2009,18 +1978,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 }
                 logger.debug(f"Async response method configuration: {json.dumps(debug_info, indent=2, default=str)}")
             
-            # Build messages list
-            messages = []
-            if system_prompt:
-                # Skip system messages for legacy o1 models as they don't support them
-                if not self._needs_system_message_skip():
-                    messages.append({"role": "system", "content": system_prompt})
-            
-            # Add prompt to messages
-            if isinstance(prompt, list):
-                messages.append({"role": "user", "content": prompt})
-            else:
-                messages.append({"role": "user", "content": prompt})
+            # Build messages list using shared helper (simplified version without JSON output)
+            messages, _ = self._build_messages(
+                prompt=prompt,
+                system_prompt=system_prompt
+            )
 
             # Get response from LiteLLM
             if stream:
@@ -2076,36 +2038,44 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             display_error(f"Error in response_async: {str(error)}")
             raise
 
-    def _generate_tool_definition(self, function_name: str) -> Optional[Dict]:
-        """Generate a tool definition from a function name."""
-        logging.debug(f"Attempting to generate tool definition for: {function_name}")
-        
-        # First try to get the tool definition if it exists
-        tool_def_name = f"{function_name}_definition"
-        tool_def = globals().get(tool_def_name)
-        logging.debug(f"Looking for {tool_def_name} in globals: {tool_def is not None}")
-        
-        if not tool_def:
-            import __main__
-            tool_def = getattr(__main__, tool_def_name, None)
-            logging.debug(f"Looking for {tool_def_name} in __main__: {tool_def is not None}")
-        
-        if tool_def:
-            logging.debug(f"Found tool definition: {tool_def}")
-            return tool_def
+    def _generate_tool_definition(self, function_or_name) -> Optional[Dict]:
+        """Generate a tool definition from a function or function name."""
+        if callable(function_or_name):
+            # Function object passed directly
+            func = function_or_name
+            function_name = func.__name__
+            logging.debug(f"Generating tool definition for callable: {function_name}")
+        else:
+            # Function name string passed
+            function_name = function_or_name
+            logging.debug(f"Attempting to generate tool definition for: {function_name}")
+            
+            # First try to get the tool definition if it exists
+            tool_def_name = f"{function_name}_definition"
+            tool_def = globals().get(tool_def_name)
+            logging.debug(f"Looking for {tool_def_name} in globals: {tool_def is not None}")
+            
+            if not tool_def:
+                import __main__
+                tool_def = getattr(__main__, tool_def_name, None)
+                logging.debug(f"Looking for {tool_def_name} in __main__: {tool_def is not None}")
+            
+            if tool_def:
+                logging.debug(f"Found tool definition: {tool_def}")
+                return tool_def
 
-        # Try to find the function
-        func = globals().get(function_name)
-        logging.debug(f"Looking for {function_name} in globals: {func is not None}")
-        
-        if not func:
-            import __main__
-            func = getattr(__main__, function_name, None)
-            logging.debug(f"Looking for {function_name} in __main__: {func is not None}")
-        
-        if not func or not callable(func):
-            logging.debug(f"Function {function_name} not found or not callable")
-            return None
+            # Try to find the function
+            func = globals().get(function_name)
+            logging.debug(f"Looking for {function_name} in globals: {func is not None}")
+            
+            if not func:
+                import __main__
+                func = getattr(__main__, function_name, None)
+                logging.debug(f"Looking for {function_name} in __main__: {func is not None}")
+            
+            if not func or not callable(func):
+                logging.debug(f"Function {function_name} not found or not callable")
+                return None
 
         import inspect
         # Handle Langchain and CrewAI tools

{praisonaiagents-0.0.111.dist-info → praisonaiagents-0.0.113.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.111
+Version: 0.0.113
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.111.dist-info → praisonaiagents-0.0.113.dist-info}/RECORD

@@ -16,7 +16,7 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=OKPar-XGyAp1ndmbOOdCgqFnTCqpOThYVSIZRxZyP58,15683
 praisonaiagents/llm/__init__.py,sha256=bSywIHBHH0YUf4hSx-FmFXkRv2g1Rlhuk-gjoImE8j8,925
-praisonaiagents/llm/llm.py,sha256=e6lER7PVJsmY7ytzTG-PoJgriRjNjUP1_edaecxRLB4,113777
+praisonaiagents/llm/llm.py,sha256=z7o4tlKO0NJCqaXlnlwtPT768YjAB6tqNe_lg2KMTkk,111271
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=-fFx4MHffnN2woLnnV7Pzx3-1SFkn2j8Gp5F5ZIwKJ0,19698
 praisonaiagents/mcp/mcp_sse.py,sha256=z8TMFhW9xuLQ7QnpOa3n1-nSHt0-Bf27qso0u4qxYSY,8357
@@ -52,7 +52,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.111.dist-info/METADATA,sha256=pmzoXOPF5cX0ua93z4KDy0Cia78iG89jdKztI6hNjvE,1669
-praisonaiagents-0.0.111.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.111.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.111.dist-info/RECORD,,
+praisonaiagents-0.0.113.dist-info/METADATA,sha256=er3TyTx5TQPXGEtyNVBXkNnUUKo8jf7nBtv908Y7WlY,1669
+praisonaiagents-0.0.113.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.113.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.113.dist-info/RECORD,,