praisonaiagents 0.0.112__py3-none-any.whl → 0.0.114__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -1,12 +1,13 @@
 import os
 import time
 import json
+import copy
 import logging
 import asyncio
 from typing import List, Optional, Any, Dict, Union, Literal, TYPE_CHECKING, Callable, Tuple
 from rich.console import Console
 from rich.live import Live
-from openai import AsyncOpenAI
+from ..llm import get_openai_client
 from ..main import (
     display_error,
     display_tool_call,
@@ -15,7 +16,6 @@ from ..main import (
     display_generating,
     display_self_reflection,
     ReflectionOutput,
-    client,
     adisplay_instruction,
     approval_callback
 )
@@ -85,6 +85,13 @@ class ChatCompletion:
     service_tier: Optional[str] = None
     usage: Optional[CompletionUsage] = None
 
+@dataclass
+class ToolCall:
+    """Tool call representation compatible with OpenAI format"""
+    id: str
+    type: str
+    function: Dict[str, Any]
+
 def process_stream_chunks(chunks):
     """Process streaming chunks into combined response"""
     if not chunks:
@@ -156,9 +163,8 @@ def process_stream_chunks(chunks):
         processed_tool_calls = []
         if tool_calls:
             try:
-                from openai.types.chat import ChatCompletionMessageToolCall
                 for tc in tool_calls:
-                    tool_call = ChatCompletionMessageToolCall(
+                    tool_call = ToolCall(
                         id=tc["id"],
                         type=tc["type"],
                         function={
@@ -513,6 +519,9 @@ class Agent:
         self.instructions = instructions
         # Check for model name in environment variable if not provided
         self._using_custom_llm = False
+        
+        # Initialize OpenAI client for direct API calls
+        self._openai_client = get_openai_client(api_key=api_key, base_url=base_url)
 
         # If base_url is provided, always create a custom LLM instance
         if base_url:
@@ -831,6 +840,132 @@ Your Goal: {self.goal}
         
         return current_response
 
+    def _build_messages(self, prompt, temperature=0.2, output_json=None, output_pydantic=None):
+        """Build messages list for chat completion.
+        
+        Args:
+            prompt: The user prompt (str or list)
+            temperature: Temperature for the chat
+            output_json: Optional Pydantic model for JSON output
+            output_pydantic: Optional Pydantic model for JSON output (alias)
+            
+        Returns:
+            tuple: (messages list, original prompt)
+        """
+        messages = []
+        
+        # Build system prompt if enabled
+        system_prompt = None
+        if self.use_system_prompt:
+            system_prompt = f"""{self.backstory}\n
+Your Role: {self.role}\n
+Your Goal: {self.goal}
+            """
+            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())}"
+            
+            messages.append({"role": "system", "content": system_prompt})
+        
+        # Add chat history
+        messages.extend(self.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 deep copy to avoid modifying the original
+                prompt = copy.deepcopy(prompt)
+                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):
+            # If we receive a multimodal prompt list, place it directly in the user message
+            messages.append({"role": "user", "content": prompt})
+        else:
+            messages.append({"role": "user", "content": prompt})
+        
+        return messages, original_prompt
+
+    def _format_tools_for_completion(self, tools=None):
+        """Format tools for OpenAI completion API.
+        
+        Supports:
+        - Pre-formatted OpenAI tools (dicts with type='function')
+        - Lists of pre-formatted tools
+        - Callable functions
+        - String function names
+        - Objects with to_openai_tool() method
+        
+        Args:
+            tools: List of tools in various formats or None to use self.tools
+            
+        Returns:
+            List of formatted tools or empty list
+        """
+        if tools is None:
+            tools = self.tools
+        
+        if not tools:
+            return []
+            
+        formatted_tools = []
+        for tool in tools:
+            # Handle pre-formatted OpenAI tools
+            if isinstance(tool, dict) and tool.get('type') == 'function':
+                # Validate nested dictionary structure before accessing
+                if 'function' in tool and isinstance(tool['function'], dict) and 'name' in tool['function']:
+                    formatted_tools.append(tool)
+                else:
+                    logging.warning(f"Skipping malformed OpenAI tool: missing function or name")
+            # Handle lists of tools
+            elif isinstance(tool, list):
+                for subtool in tool:
+                    if isinstance(subtool, dict) and subtool.get('type') == 'function':
+                        # Validate nested dictionary structure before accessing
+                        if 'function' in subtool and isinstance(subtool['function'], dict) and 'name' in subtool['function']:
+                            formatted_tools.append(subtool)
+                        else:
+                            logging.warning(f"Skipping malformed OpenAI tool in list: missing function or name")
+            # Handle string tool names
+            elif isinstance(tool, str):
+                tool_def = self._generate_tool_definition(tool)
+                if tool_def:
+                    formatted_tools.append(tool_def)
+                else:
+                    logging.warning(f"Could not generate definition for tool: {tool}")
+            # Handle objects with to_openai_tool method (MCP tools)
+            elif hasattr(tool, "to_openai_tool"):
+                openai_tools = tool.to_openai_tool()
+                # MCP tools can return either a single tool or a list of tools
+                if isinstance(openai_tools, list):
+                    formatted_tools.extend(openai_tools)
+                elif openai_tools is not None:
+                    formatted_tools.append(openai_tools)
+            # Handle callable functions
+            elif callable(tool):
+                tool_def = self._generate_tool_definition(tool.__name__)
+                if tool_def:
+                    formatted_tools.append(tool_def)
+            else:
+                logging.warning(f"Tool {tool} not recognized")
+        
+        # Validate JSON serialization before returning
+        if formatted_tools:
+            try:
+                json.dumps(formatted_tools)  # Validate serialization
+            except (TypeError, ValueError) as e:
+                logging.error(f"Tools are not JSON serializable: {e}")
+                return []
+                
+        return formatted_tools
+
     def generate_task(self) -> 'Task':
         """Generate a Task object from the agent's instructions"""
         from ..task.task import Task
@@ -998,7 +1133,7 @@ Your Goal: {self.goal}
         """Process streaming response and return final response"""
         try:
             # Create the response stream
-            response_stream = client.chat.completions.create(
+            response_stream = self._openai_client.sync_client.chat.completions.create(
                 model=self.llm,
                 messages=messages,
                 temperature=temperature,
@@ -1045,26 +1180,8 @@ Your Goal: {self.goal}
         start_time = time.time()
         logging.debug(f"{self.name} sending messages to LLM: {messages}")
 
-        formatted_tools = []
-        if tools is None:
-            tools = self.tools
-        if tools:
-            for tool in tools:
-                if isinstance(tool, str):
-                    # Generate tool definition for string tool names
-                    tool_def = self._generate_tool_definition(tool)
-                    if tool_def:
-                        formatted_tools.append(tool_def)
-                    else:
-                        logging.warning(f"Could not generate definition for tool: {tool}")
-                elif isinstance(tool, dict):
-                    formatted_tools.append(tool)
-                elif hasattr(tool, "to_openai_tool"):
-                    formatted_tools.append(tool.to_openai_tool())
-                elif callable(tool):
-                    formatted_tools.append(self._generate_tool_definition(tool.__name__))
-                else:
-                    logging.warning(f"Tool {tool} not recognized")
+        # Use the new _format_tools_for_completion helper method
+        formatted_tools = self._format_tools_for_completion(tools)
 
         try:
             # Use the custom LLM instance if available
@@ -1123,7 +1240,7 @@ Your Goal: {self.goal}
                         )
                     else:
                         # Process as regular non-streaming response
-                        final_response = client.chat.completions.create(
+                        final_response = self._openai_client.sync_client.chat.completions.create(
                             model=self.llm,
                             messages=messages,
                             temperature=temperature,
@@ -1134,15 +1251,34 @@ Your Goal: {self.goal}
                     tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
 
                     if tool_calls:
+                        # Convert ToolCall dataclass objects to dict for JSON serialization
+                        serializable_tool_calls = []
+                        for tc in tool_calls:
+                            if isinstance(tc, ToolCall):
+                                # Convert dataclass to dict
+                                serializable_tool_calls.append({
+                                    "id": tc.id,
+                                    "type": tc.type,
+                                    "function": tc.function
+                                })
+                            else:
+                                # Already an OpenAI object, keep as is
+                                serializable_tool_calls.append(tc)
+                        
                         messages.append({
                             "role": "assistant", 
                             "content": final_response.choices[0].message.content,
-                            "tool_calls": tool_calls
+                            "tool_calls": serializable_tool_calls
                         })
 
                         for tool_call in tool_calls:
-                            function_name = tool_call.function.name
-                            arguments = json.loads(tool_call.function.arguments)
+                            # Handle both ToolCall dataclass and OpenAI object
+                            if isinstance(tool_call, ToolCall):
+                                function_name = tool_call.function["name"]
+                                arguments = json.loads(tool_call.function["arguments"])
+                            else:
+                                function_name = tool_call.function.name
+                                arguments = json.loads(tool_call.function.arguments)
 
                             if self.verbose:
                                 display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
@@ -1155,15 +1291,20 @@ Your Goal: {self.goal}
 
                             messages.append({
                                 "role": "tool",
-                                "tool_call_id": tool_call.id,
+                                "tool_call_id": tool_call.id if hasattr(tool_call, 'id') else tool_call['id'],
                                 "content": results_str
                             })
 
                         # Check if we should continue (for tools like sequential thinking)
                         should_continue = False
                         for tool_call in tool_calls:
-                            function_name = tool_call.function.name
-                            arguments = json.loads(tool_call.function.arguments)
+                            # Handle both ToolCall dataclass and OpenAI object
+                            if isinstance(tool_call, ToolCall):
+                                function_name = tool_call.function["name"]
+                                arguments = json.loads(tool_call.function["arguments"])
+                            else:
+                                function_name = tool_call.function.name
+                                arguments = json.loads(tool_call.function.arguments)
                             
                             # For sequential thinking tool, check if nextThoughtNeeded is True
                             if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
@@ -1181,7 +1322,7 @@ Your Goal: {self.goal}
                                     reasoning_steps=reasoning_steps
                                 )
                             else:
-                                final_response = client.chat.completions.create(
+                                final_response = self._openai_client.sync_client.chat.completions.create(
                                     model=self.llm,
                                     messages=messages,
                                     temperature=temperature,
@@ -1297,40 +1438,8 @@ Your Goal: {self.goal}
                 display_error(f"Error in LLM chat: {e}")
                 return None
         else:
-            if self.use_system_prompt:
-                system_prompt = f"""{self.backstory}\n
-Your Role: {self.role}\n
-Your Goal: {self.goal}
-                """
-                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())}"
-            else:
-                system_prompt = None
-
-            messages = []
-            if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
-            messages.extend(self.chat_history)
-
-            # Modify prompt if output_json or output_pydantic is specified
-            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 multimodal prompts, append to the text content
-                    for item in prompt:
-                        if item["type"] == "text":
-                            item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                            break
-
-            if isinstance(prompt, list):
-                # If we receive a multimodal prompt list, place it directly in the user message
-                messages.append({"role": "user", "content": prompt})
-            else:
-                messages.append({"role": "user", "content": prompt})
+            # Use the new _build_messages helper method
+            messages, original_prompt = self._build_messages(prompt, temperature, output_json, output_pydantic)
 
             final_response_text = None
             reflection_count = 0
@@ -1405,7 +1514,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     messages.append({"role": "user", "content": reflection_prompt})
 
                     try:
-                        reflection_response = client.beta.chat.completions.parse(
+                        reflection_response = self._openai_client.sync_client.beta.chat.completions.parse(
                             model=self.reflect_llm if self.reflect_llm else self.llm,
                             messages=messages,
                             temperature=temperature,
@@ -1566,38 +1675,8 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     return None
 
             # For OpenAI client
-            if self.use_system_prompt:
-                system_prompt = f"""{self.backstory}\n
-Your Role: {self.role}\n
-Your Goal: {self.goal}
-                """
-                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())}"
-            else:
-                system_prompt = None
-
-            messages = []
-            if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
-            messages.extend(self.chat_history)
-
-            # Modify prompt if output_json or output_pydantic is specified
-            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
-
-            if isinstance(prompt, list):
-                messages.append({"role": "user", "content": prompt})
-            else:
-                messages.append({"role": "user", "content": prompt})
+            # Use the new _build_messages helper method
+            messages, original_prompt = self._build_messages(prompt, temperature, output_json, output_pydantic)
 
             reflection_count = 0
             start_time = time.time()
@@ -1619,27 +1698,12 @@ Your Goal: {self.goal}
                                 agent_tools=agent_tools
                             )
 
-                    # Format tools if provided
-                    formatted_tools = []
-                    if tools:
-                        for tool in tools:
-                            if isinstance(tool, str):
-                                tool_def = self._generate_tool_definition(tool)
-                                if tool_def:
-                                    formatted_tools.append(tool_def)
-                            elif isinstance(tool, dict):
-                                formatted_tools.append(tool)
-                            elif hasattr(tool, "to_openai_tool"):
-                                formatted_tools.append(tool.to_openai_tool())
-                            elif callable(tool):
-                                formatted_tools.append(self._generate_tool_definition(tool.__name__))
-
-                    # Create async OpenAI client
-                    async_client = AsyncOpenAI()
+                    # Use the new _format_tools_for_completion helper method
+                    formatted_tools = self._format_tools_for_completion(tools)
 
                     # Make the API call based on the type of request
                     if tools:
-                        response = await async_client.chat.completions.create(
+                        response = await self._openai_client.async_client.chat.completions.create(
                             model=self.llm,
                             messages=messages,
                             temperature=temperature,
@@ -1651,7 +1715,7 @@ Your Goal: {self.goal}
                             logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
                         return result
                     elif output_json or output_pydantic:
-                        response = await async_client.chat.completions.create(
+                        response = await self._openai_client.async_client.chat.completions.create(
                             model=self.llm,
                             messages=messages,
                             temperature=temperature,
@@ -1663,7 +1727,7 @@ Your Goal: {self.goal}
                             logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
                         return response.choices[0].message.content
                     else:
-                        response = await async_client.chat.completions.create(
+                        response = await self._openai_client.async_client.chat.completions.create(
                             model=self.llm,
                             messages=messages,
                             temperature=temperature
@@ -1690,7 +1754,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 ]
                                 
                                 try:
-                                    reflection_response = await async_client.beta.chat.completions.parse(
+                                    reflection_response = await self._openai_client.async_client.beta.chat.completions.parse(
                                         model=self.reflect_llm if self.reflect_llm else self.llm,
                                         messages=reflection_messages,
                                         temperature=temperature,
@@ -1720,7 +1784,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                         {"role": "user", "content": "Now regenerate your response using the reflection you made"}
                                     ]
                                     
-                                    new_response = await async_client.chat.completions.create(
+                                    new_response = await self._openai_client.async_client.chat.completions.create(
                                         model=self.llm,
                                         messages=regenerate_messages,
                                         temperature=temperature
@@ -1796,8 +1860,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         {"role": "user", "content": formatted_results + "\nPlease process these results and provide a final response."}
                     ]
                     try:
-                        async_client = AsyncOpenAI()
-                        final_response = await async_client.chat.completions.create(
+                        final_response = await self._openai_client.async_client.chat.completions.create(
                             model=self.llm,
                             messages=messages,
                             temperature=0.2,

praisonaiagents/llm/__init__.py

@@ -20,6 +20,7 @@ logging.basicConfig(level=logging.WARNING)
 
 # Import after suppressing warnings
 from .llm import LLM, LLMContextLengthExceededException
+from .openai_client import OpenAIClient, get_openai_client
 
 # Ensure telemetry is disabled after import as well
 try:
@@ -28,4 +29,4 @@ try:
 except ImportError:
     pass
 
-__all__ = ["LLM", "LLMContextLengthExceededException"]
+__all__ = ["LLM", "LLMContextLengthExceededException", "OpenAIClient", "get_openai_client"]

praisonaiagents/llm/llm.py

@@ -364,6 +364,66 @@ class LLM:
         
         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,
         prompt: Union[str, List[Dict]],
@@ -445,33 +505,7 @@ 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
+            formatted_tools = self._format_tools_for_litellm(tools)
             
             # Build messages list using shared helper
             messages, original_prompt = self._build_messages(
@@ -1202,74 +1236,8 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             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:
@@ -2070,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/llm/openai_client.py

@@ -0,0 +1,260 @@
+"""
+OpenAI Client Module
+
+This module provides a unified interface for OpenAI API interactions,
+supporting both synchronous and asynchronous operations.
+"""
+
+import os
+import logging
+from typing import Any, Dict, List, Optional, Union, AsyncIterator, Iterator
+from openai import OpenAI, AsyncOpenAI
+from openai.types.chat import ChatCompletionChunk
+import asyncio
+from pydantic import BaseModel
+
+# Constants
+LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
+
+class OpenAIClient:
+    """
+    Unified OpenAI client wrapper for sync/async operations.
+    
+    This class encapsulates all OpenAI-specific logic, providing a clean
+    interface for chat completions, streaming, and structured outputs.
+    """
+    
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        """
+        Initialize the OpenAI client with proper API key handling.
+        
+        Args:
+            api_key: OpenAI API key (defaults to OPENAI_API_KEY env var)
+            base_url: Custom base URL for API endpoints (defaults to OPENAI_API_BASE env var)
+        """
+        # Use provided values or fall back to environment variables
+        self.api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        self.base_url = base_url or os.environ.get("OPENAI_API_BASE") or os.environ.get("OPENAI_BASE_URL")
+        
+        # For local servers like LM Studio, allow minimal API key
+        if self.base_url and not self.api_key:
+            self.api_key = LOCAL_SERVER_API_KEY_PLACEHOLDER
+        elif not self.api_key:
+            raise ValueError(
+                "OPENAI_API_KEY environment variable is required for the default OpenAI service. "
+                "If you are targeting a local server (e.g., LM Studio), ensure OPENAI_API_BASE is set "
+                f"(e.g., 'http://localhost:1234/v1') and you can use a placeholder API key by setting OPENAI_API_KEY='{LOCAL_SERVER_API_KEY_PLACEHOLDER}'"
+            )
+        
+        # Initialize synchronous client (lazy loading for async)
+        self._sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+        self._async_client = None
+        
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+    
+    @property
+    def sync_client(self) -> OpenAI:
+        """Get the synchronous OpenAI client."""
+        return self._sync_client
+    
+    @property
+    def async_client(self) -> AsyncOpenAI:
+        """Get the asynchronous OpenAI client (lazy initialization)."""
+        if self._async_client is None:
+            self._async_client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+        return self._async_client
+    
+    def create_completion(
+        self,
+        messages: List[Dict[str, Any]],
+        model: str = "gpt-4o",
+        temperature: float = 0.7,
+        stream: bool = False,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs
+    ) -> Union[Any, Iterator[ChatCompletionChunk]]:
+        """
+        Create a chat completion using the synchronous client.
+        
+        Args:
+            messages: List of message dictionaries
+            model: Model to use for completion
+            temperature: Sampling temperature
+            stream: Whether to stream the response
+            tools: List of tools/functions available
+            tool_choice: Tool selection preference
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            ChatCompletion object or stream iterator
+        """
+        params = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "stream": stream,
+            **kwargs
+        }
+        
+        # Add tools if provided
+        if tools:
+            params["tools"] = tools
+            if tool_choice is not None:
+                params["tool_choice"] = tool_choice
+        
+        try:
+            return self._sync_client.chat.completions.create(**params)
+        except Exception as e:
+            self.logger.error(f"Error creating completion: {e}")
+            raise
+    
+    async def acreate_completion(
+        self,
+        messages: List[Dict[str, Any]],
+        model: str = "gpt-4o",
+        temperature: float = 0.7,
+        stream: bool = False,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs
+    ) -> Union[Any, AsyncIterator[ChatCompletionChunk]]:
+        """
+        Create a chat completion using the asynchronous client.
+        
+        Args:
+            messages: List of message dictionaries
+            model: Model to use for completion
+            temperature: Sampling temperature
+            stream: Whether to stream the response
+            tools: List of tools/functions available
+            tool_choice: Tool selection preference
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            ChatCompletion object or async stream iterator
+        """
+        params = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "stream": stream,
+            **kwargs
+        }
+        
+        # Add tools if provided
+        if tools:
+            params["tools"] = tools
+            if tool_choice is not None:
+                params["tool_choice"] = tool_choice
+        
+        try:
+            return await self.async_client.chat.completions.create(**params)
+        except Exception as e:
+            self.logger.error(f"Error creating async completion: {e}")
+            raise
+    
+    def parse_structured_output(
+        self,
+        messages: List[Dict[str, Any]],
+        response_format: BaseModel,
+        model: str = "gpt-4o",
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Any:
+        """
+        Parse structured output using the beta.chat.completions.parse API.
+        
+        Args:
+            messages: List of message dictionaries
+            response_format: Pydantic model for response validation
+            model: Model to use for completion
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            Parsed response according to the response_format
+        """
+        try:
+            response = self._sync_client.beta.chat.completions.parse(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                response_format=response_format,
+                **kwargs
+            )
+            return response.choices[0].message.parsed
+        except Exception as e:
+            self.logger.error(f"Error parsing structured output: {e}")
+            raise
+    
+    async def aparse_structured_output(
+        self,
+        messages: List[Dict[str, Any]],
+        response_format: BaseModel,
+        model: str = "gpt-4o",
+        temperature: float = 0.7,
+        **kwargs
+    ) -> Any:
+        """
+        Parse structured output using the async beta.chat.completions.parse API.
+        
+        Args:
+            messages: List of message dictionaries
+            response_format: Pydantic model for response validation
+            model: Model to use for completion
+            temperature: Sampling temperature
+            **kwargs: Additional parameters to pass to the API
+            
+        Returns:
+            Parsed response according to the response_format
+        """
+        try:
+            response = await self.async_client.beta.chat.completions.parse(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                response_format=response_format,
+                **kwargs
+            )
+            return response.choices[0].message.parsed
+        except Exception as e:
+            self.logger.error(f"Error parsing async structured output: {e}")
+            raise
+    
+    def close(self):
+        """Close the OpenAI clients."""
+        if hasattr(self._sync_client, 'close'):
+            self._sync_client.close()
+        if self._async_client and hasattr(self._async_client, 'close'):
+            self._async_client.close()
+    
+    async def aclose(self):
+        """Asynchronously close the OpenAI clients."""
+        if hasattr(self._sync_client, 'close'):
+            await asyncio.to_thread(self._sync_client.close)
+        if self._async_client and hasattr(self._async_client, 'aclose'):
+            await self._async_client.aclose()
+
+
+# Global client instance (similar to main.py pattern)
+_global_client = None
+
+def get_openai_client(api_key: Optional[str] = None, base_url: Optional[str] = None) -> OpenAIClient:
+    """
+    Get or create a global OpenAI client instance.
+    
+    Args:
+        api_key: OpenAI API key (defaults to OPENAI_API_KEY env var)
+        base_url: Custom base URL for API endpoints
+        
+    Returns:
+        OpenAIClient instance
+    """
+    global _global_client
+    
+    if _global_client is None:
+        _global_client = OpenAIClient(api_key=api_key, base_url=base_url)
+    
+    return _global_client

{praisonaiagents-0.0.112.dist-info → praisonaiagents-0.0.114.dist-info}/METADATA

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

{praisonaiagents-0.0.112.dist-info → praisonaiagents-0.0.114.dist-info}/RECORD

@@ -3,7 +3,7 @@ praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9
 praisonaiagents/main.py,sha256=_-XE7_Y7ChvtLQMivfNFrrnAhv4wSSDhH9WJMWlkS0w,16315
 praisonaiagents/session.py,sha256=d-CZPYikOHb0q-H9f_IWKJsypnQfz1YKeLLkyxs6oDo,15532
 praisonaiagents/agent/__init__.py,sha256=IhIDtAkfJ99cxbttwou52coih_AejS2-jpazsX6LbDY,350
-praisonaiagents/agent/agent.py,sha256=20w8H2Fqu8oxX6pbvdEx2VBX6G-U7_lsdjRNI89SwTg,113894
+praisonaiagents/agent/agent.py,sha256=a5SxvqzNi2m5ralng0vTBT0zdEDicQmq0lEvFJKxIgM,116873
 praisonaiagents/agent/handoff.py,sha256=Saq0chqfvC6Zf5UbXvmctybbehqnotrXn72JsS-76Q0,13099
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
@@ -15,8 +15,9 @@ praisonaiagents/guardrails/llm_guardrail.py,sha256=MTTqmYDdZX-18QN9T17T5P_6H2qnV
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 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=Gk4ILbegZtxc3iFCI2H2Zglfc73xNhsEjW1fWu12ltM,113025
+praisonaiagents/llm/__init__.py,sha256=mWzKHtjcpmUl20HMdjg_Gbyb3-sPHxmiS2LGluVKB3A,1021
+praisonaiagents/llm/llm.py,sha256=z7o4tlKO0NJCqaXlnlwtPT768YjAB6tqNe_lg2KMTkk,111271
+praisonaiagents/llm/openai_client.py,sha256=uzSeM6OtBoEjrjBLPjbRBt7sPwCz-kwl6Yk8rBE_6Mo,9205
 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 +53,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.112.dist-info/METADATA,sha256=qKFv-nDM6_21eStVCY503Btr0plIKKhVjZQOg6V2jDM,1669
-praisonaiagents-0.0.112.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.112.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.112.dist-info/RECORD,,
+praisonaiagents-0.0.114.dist-info/METADATA,sha256=zX76iv2EO8DxcWXRGZ244CVqllOUBqiRabTTCom27DM,1669
+praisonaiagents-0.0.114.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.114.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.114.dist-info/RECORD,,