praisonaiagents 0.0.113__tar.gz → 0.0.114__tar.gz

{praisonaiagents-0.0.113 → praisonaiagents-0.0.114}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.113
+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.113 → praisonaiagents-0.0.114}/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-0.0.113 → praisonaiagents-0.0.114}/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-0.0.114/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.113 → praisonaiagents-0.0.114}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.113
+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.113 → praisonaiagents-0.0.114}/praisonaiagents.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ praisonaiagents/knowledge/chunking.py
 praisonaiagents/knowledge/knowledge.py
 praisonaiagents/llm/__init__.py
 praisonaiagents/llm/llm.py
+praisonaiagents/llm/openai_client.py
 praisonaiagents/mcp/__init__.py
 praisonaiagents/mcp/mcp.py
 praisonaiagents/mcp/mcp_sse.py

{praisonaiagents-0.0.113 → praisonaiagents-0.0.114}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.113"
+version = "0.0.114"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [