Update PraisonAI and related dependencies to version 2.2.43 and praisonaiagents to version 0.0.116 across Dockerfiles, README, and project files for consistency and compatibility.

fix: add array schema validation to llm.py for MCP tools compatibility

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.2.39" \
+    "praisonai>=2.2.43" \
     "praisonai[api]" \
     gunicorn \
     markdown

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.39" \
+    "praisonai>=2.2.43" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.39" \
+    "praisonai>=2.2.43" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=2.2.39" \
+    "praisonai>=2.2.43" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docker/README.md

@@ -121,7 +121,7 @@ healthcheck:
 ## 📦 Package Versions
 
 All Docker images use consistent, up-to-date versions:
-- PraisonAI: `>=2.2.39`
+- PraisonAI: `>=2.2.43`
 - PraisonAI Agents: `>=0.0.92`
 - Python: `3.11-slim`
 
@@ -218,7 +218,7 @@ docker-compose up -d
 ### Version Pinning
 To use specific versions, update the Dockerfile:
 ```dockerfile
-RUN pip install "praisonai==2.2.39" "praisonaiagents==0.0.92"
+RUN pip install "praisonai==2.2.43" "praisonaiagents==0.0.92"
 ```
 
 ## 🌐 Production Deployment

src/praisonai-agents/basic-agents-tools.py

@@ -0,0 +1,12 @@
+from praisonaiagents import Agent
+
+def get_weather(city: str) -> str:
+    return f"The weather in {city} is sunny"
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gpt-4o-mini",
+    tools=[get_weather]
+)
+
+agent.start("What is the weather in Tokyo?")

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -1,12 +1,23 @@
 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,
+    ChatCompletionMessage,
+    Choice,
+    CompletionTokensDetails,
+    PromptTokensDetails,
+    CompletionUsage,
+    ChatCompletion,
+    ToolCall,
+    process_stream_chunks
+)
 from ..main import (
     display_error,
     display_tool_call,
@@ -15,13 +26,11 @@ from ..main import (
     display_generating,
     display_self_reflection,
     ReflectionOutput,
-    client,
     adisplay_instruction,
     approval_callback
 )
 import inspect
 import uuid
-from dataclasses import dataclass
 
 # Global variables for API server
 _server_started = {}  # Dict of port -> started boolean
@@ -35,175 +44,6 @@ if TYPE_CHECKING:
     from ..main import TaskOutput
     from ..handoff import Handoff
 
-@dataclass
-class ChatCompletionMessage:
-    content: str
-    role: str = "assistant"
-    refusal: Optional[str] = None
-    audio: Optional[str] = None
-    function_call: Optional[dict] = None
-    tool_calls: Optional[List] = None
-    reasoning_content: Optional[str] = None
-
-@dataclass
-class Choice:
-    finish_reason: Optional[str]
-    index: int
-    message: ChatCompletionMessage
-    logprobs: Optional[dict] = None
-
-@dataclass
-class CompletionTokensDetails:
-    accepted_prediction_tokens: Optional[int] = None
-    audio_tokens: Optional[int] = None
-    reasoning_tokens: Optional[int] = None
-    rejected_prediction_tokens: Optional[int] = None
-
-@dataclass
-class PromptTokensDetails:
-    audio_tokens: Optional[int] = None
-    cached_tokens: int = 0
-
-@dataclass
-class CompletionUsage:
-    completion_tokens: int = 0
-    prompt_tokens: int = 0
-    total_tokens: int = 0
-    completion_tokens_details: Optional[CompletionTokensDetails] = None
-    prompt_tokens_details: Optional[PromptTokensDetails] = None
-    prompt_cache_hit_tokens: int = 0
-    prompt_cache_miss_tokens: int = 0
-
-@dataclass
-class ChatCompletion:
-    id: str
-    choices: List[Choice]
-    created: int
-    model: str
-    object: str = "chat.completion"
-    system_fingerprint: Optional[str] = None
-    service_tier: Optional[str] = None
-    usage: Optional[CompletionUsage] = None
-
-def process_stream_chunks(chunks):
-    """Process streaming chunks into combined response"""
-    if not chunks:
-        return None
-    
-    try:
-        first_chunk = chunks[0]
-        last_chunk = chunks[-1]
-        
-        # Basic metadata
-        id = getattr(first_chunk, "id", None) 
-        created = getattr(first_chunk, "created", None)
-        model = getattr(first_chunk, "model", None)
-        system_fingerprint = getattr(first_chunk, "system_fingerprint", None)
-        
-        # Track usage
-        completion_tokens = 0
-        prompt_tokens = 0
-        
-        content_list = []
-        reasoning_list = []
-        tool_calls = []
-        current_tool_call = None
-
-        # First pass: Get initial tool call data
-        for chunk in chunks:
-            if not hasattr(chunk, "choices") or not chunk.choices:
-                continue
-            
-            delta = getattr(chunk.choices[0], "delta", None)
-            if not delta:
-                continue
-
-            # Handle content and reasoning
-            if hasattr(delta, "content") and delta.content:
-                content_list.append(delta.content)
-            if hasattr(delta, "reasoning_content") and delta.reasoning_content:
-                reasoning_list.append(delta.reasoning_content)
-            
-            # Handle tool calls
-            if hasattr(delta, "tool_calls") and delta.tool_calls:
-                for tool_call_delta in delta.tool_calls:
-                    if tool_call_delta.index is not None and tool_call_delta.id:
-                        # Found the initial tool call
-                        current_tool_call = {
-                            "id": tool_call_delta.id,
-                            "type": "function",
-                            "function": {
-                                "name": tool_call_delta.function.name,
-                                "arguments": ""
-                            }
-                        }
-                        while len(tool_calls) <= tool_call_delta.index:
-                            tool_calls.append(None)
-                        tool_calls[tool_call_delta.index] = current_tool_call
-                        current_tool_call = tool_calls[tool_call_delta.index]
-                    elif current_tool_call is not None and hasattr(tool_call_delta.function, "arguments"):
-                        if tool_call_delta.function.arguments:
-                            current_tool_call["function"]["arguments"] += tool_call_delta.function.arguments
-
-        # Remove any None values and empty tool calls
-        tool_calls = [tc for tc in tool_calls if tc and tc["id"] and tc["function"]["name"]]
-
-        combined_content = "".join(content_list) if content_list else ""
-        combined_reasoning = "".join(reasoning_list) if reasoning_list else None
-        finish_reason = getattr(last_chunk.choices[0], "finish_reason", None) if hasattr(last_chunk, "choices") and last_chunk.choices else None
-
-        # Create ToolCall objects
-        processed_tool_calls = []
-        if tool_calls:
-            try:
-                from openai.types.chat import ChatCompletionMessageToolCall
-                for tc in tool_calls:
-                    tool_call = ChatCompletionMessageToolCall(
-                        id=tc["id"],
-                        type=tc["type"],
-                        function={
-                            "name": tc["function"]["name"],
-                            "arguments": tc["function"]["arguments"]
-                        }
-                    )
-                    processed_tool_calls.append(tool_call)
-            except Exception as e:
-                print(f"Error processing tool call: {e}")
-
-        message = ChatCompletionMessage(
-            content=combined_content,
-            role="assistant",
-            reasoning_content=combined_reasoning,
-            tool_calls=processed_tool_calls if processed_tool_calls else None
-        )
-        
-        choice = Choice(
-            finish_reason=finish_reason or "tool_calls" if processed_tool_calls else None,
-            index=0,
-            message=message
-        )
-
-        usage = CompletionUsage(
-            completion_tokens=completion_tokens,
-            prompt_tokens=prompt_tokens,
-            total_tokens=completion_tokens + prompt_tokens,
-            completion_tokens_details=CompletionTokensDetails(),
-            prompt_tokens_details=PromptTokensDetails()
-        )
-        
-        return ChatCompletion(
-            id=id,
-            choices=[choice],
-            created=created,
-            model=model,
-            system_fingerprint=system_fingerprint,
-            usage=usage
-        )
-        
-    except Exception as e:
-        print(f"Error processing chunks: {e}")
-        return None
-
 class Agent:
     def _generate_tool_definition(self, function_name):
         """
@@ -513,6 +353,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 +674,110 @@ 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)
+        """
+        # 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}
+            """
+        
+        # Use openai_client's build_messages method
+        messages, original_prompt = self._openai_client.build_messages(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            chat_history=self.chat_history,
+            output_json=output_json,
+            output_pydantic=output_pydantic
+        )
+        
+        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
@@ -996,75 +943,23 @@ Your Goal: {self.goal}
 
     def _process_stream_response(self, messages, temperature, start_time, formatted_tools=None, reasoning_steps=False):
         """Process streaming response and return final response"""
-        try:
-            # Create the response stream
-            response_stream = client.chat.completions.create(
-                model=self.llm,
-                messages=messages,
-                temperature=temperature,
-                tools=formatted_tools if formatted_tools else None,
-                stream=True
-            )
-            
-            full_response_text = ""
-            reasoning_content = ""
-            chunks = []
-            
-            # Create Live display with proper configuration
-            with Live(
-                display_generating("", start_time),
-                console=self.console,
-                refresh_per_second=4,
-                transient=True,
-                vertical_overflow="ellipsis",
-                auto_refresh=True
-            ) as live:
-                for chunk in response_stream:
-                    chunks.append(chunk)
-                    if chunk.choices[0].delta.content:
-                        full_response_text += chunk.choices[0].delta.content
-                        live.update(display_generating(full_response_text, start_time))
-                    
-                    # Update live display with reasoning content if enabled
-                    if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
-                        rc = chunk.choices[0].delta.reasoning_content
-                        if rc:
-                            reasoning_content += rc
-                            live.update(display_generating(f"{full_response_text}\n[Reasoning: {reasoning_content}]", start_time))
-            
-            # Clear the last generating display with a blank line
-            self.console.print()
-            final_response = process_stream_chunks(chunks)
-            return final_response
-            
-        except Exception as e:
-            display_error(f"Error in stream processing: {e}")
-            return None
+        return self._openai_client.process_stream_response(
+            messages=messages,
+            model=self.llm,
+            temperature=temperature,
+            tools=formatted_tools,
+            start_time=start_time,
+            console=self.console,
+            display_fn=display_generating,
+            reasoning_steps=reasoning_steps
+        )
 
     def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, reasoning_steps=False):
         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
@@ -1106,93 +1001,27 @@ Your Goal: {self.goal}
                         reasoning_steps=reasoning_steps
                     )
             else:
-                # Use the standard OpenAI client approach
-                # Continue tool execution loop until no more tool calls are needed
-                max_iterations = 10  # Prevent infinite loops
-                iteration_count = 0
+                # Use the standard OpenAI client approach with tool support
+                def custom_display_fn(text, start_time):
+                    if self.verbose:
+                        return display_generating(text, start_time)
+                    return ""
                 
-                while iteration_count < max_iterations:
-                    if stream:
-                        # Process as streaming response with formatted tools
-                        final_response = self._process_stream_response(
-                            messages, 
-                            temperature, 
-                            start_time, 
-                            formatted_tools=formatted_tools if formatted_tools else None,
-                            reasoning_steps=reasoning_steps
-                        )
-                    else:
-                        # Process as regular non-streaming response
-                        final_response = client.chat.completions.create(
-                            model=self.llm,
-                            messages=messages,
-                            temperature=temperature,
-                            tools=formatted_tools if formatted_tools else None,
-                            stream=False
-                        )
-
-                    tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
-
-                    if tool_calls:
-                        messages.append({
-                            "role": "assistant", 
-                            "content": final_response.choices[0].message.content,
-                            "tool_calls": tool_calls
-                        })
-
-                        for tool_call in tool_calls:
-                            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}")
-
-                            tool_result = self.execute_tool(function_name, arguments)
-                            results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
-
-                            if self.verbose:
-                                display_tool_call(f"Function '{function_name}' returned: {results_str}")
-
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": 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)
-                            
-                            # For sequential thinking tool, check if nextThoughtNeeded is True
-                            if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
-                                should_continue = True
-                                break
-
-                        if not should_continue:
-                            # Get final response after tool calls
-                            if stream:
-                                final_response = self._process_stream_response(
-                                    messages, 
-                                    temperature, 
-                                    start_time,
-                                    formatted_tools=formatted_tools if formatted_tools else None,
-                                    reasoning_steps=reasoning_steps
-                                )
-                            else:
-                                final_response = client.chat.completions.create(
-                                    model=self.llm,
-                                    messages=messages,
-                                    temperature=temperature,
-                                    stream=False
-                                )
-                            break
-                        
-                        iteration_count += 1
-                    else:
-                        # No tool calls, we're done
-                        break
+                # Note: openai_client expects tools in various formats and will format them internally
+                # But since we already have formatted_tools, we can pass them directly
+                final_response = self._openai_client.chat_completion_with_tools(
+                    messages=messages,
+                    model=self.llm,
+                    temperature=temperature,
+                    tools=formatted_tools,  # Already formatted for OpenAI
+                    execute_tool_fn=self.execute_tool,
+                    stream=stream,
+                    console=self.console if self.verbose else None,
+                    display_fn=display_generating if stream and self.verbose else None,
+                    reasoning_steps=reasoning_steps,
+                    verbose=self.verbose,
+                    max_iterations=10
+                )
 
             return final_response
 
@@ -1297,40 +1126,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 +1202,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 +1363,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 +1386,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 +1403,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 +1415,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 +1442,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 +1472,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 +1548,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,

src/praisonai-agents/praisonaiagents/llm/__init__.py

@@ -20,6 +20,18 @@ logging.basicConfig(level=logging.WARNING)
 
 # Import after suppressing warnings
 from .llm import LLM, LLMContextLengthExceededException
+from .openai_client import (
+    OpenAIClient, 
+    get_openai_client,
+    ChatCompletionMessage,
+    Choice,
+    CompletionTokensDetails,
+    PromptTokensDetails,
+    CompletionUsage,
+    ChatCompletion,
+    ToolCall,
+    process_stream_chunks
+)
 
 # Ensure telemetry is disabled after import as well
 try:
@@ -28,4 +40,17 @@ try:
 except ImportError:
     pass
 
-__all__ = ["LLM", "LLMContextLengthExceededException"]
+__all__ = [
+    "LLM", 
+    "LLMContextLengthExceededException", 
+    "OpenAIClient", 
+    "get_openai_client",
+    "ChatCompletionMessage",
+    "Choice",
+    "CompletionTokensDetails",
+    "PromptTokensDetails",
+    "CompletionUsage",
+    "ChatCompletion",
+    "ToolCall",
+    "process_stream_chunks"
+]

src/praisonai-agents/praisonaiagents/llm/llm.py

@@ -364,6 +364,114 @@ class LLM:
         
         return messages, original_prompt
 
+    def _fix_array_schemas(self, schema: Dict) -> Dict:
+        """
+        Recursively fix array schemas by adding missing 'items' attribute.
+        
+        This ensures compatibility with OpenAI's function calling format which
+        requires array types to specify the type of items they contain.
+        
+        Args:
+            schema: The schema dictionary to fix
+            
+        Returns:
+            dict: The fixed schema
+        """
+        if not isinstance(schema, dict):
+            return schema
+            
+        # Create a copy to avoid modifying the original
+        fixed_schema = schema.copy()
+        
+        # Fix array types at the current level
+        if fixed_schema.get("type") == "array" and "items" not in fixed_schema:
+            # Add a default items schema for arrays without it
+            fixed_schema["items"] = {"type": "string"}
+            
+        # Recursively fix nested schemas in properties
+        if "properties" in fixed_schema and isinstance(fixed_schema["properties"], dict):
+            fixed_properties = {}
+            for prop_name, prop_schema in fixed_schema["properties"].items():
+                if isinstance(prop_schema, dict):
+                    fixed_properties[prop_name] = self._fix_array_schemas(prop_schema)
+                else:
+                    fixed_properties[prop_name] = prop_schema
+            fixed_schema["properties"] = fixed_properties
+            
+        # Fix items schema if it exists
+        if "items" in fixed_schema and isinstance(fixed_schema["items"], dict):
+            fixed_schema["items"] = self._fix_array_schemas(fixed_schema["items"])
+            
+        return fixed_schema
+
+    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']}")
+                    # Fix array schemas in the tool parameters
+                    fixed_tool = tool.copy()
+                    if 'parameters' in fixed_tool['function']:
+                        fixed_tool['function']['parameters'] = self._fix_array_schemas(fixed_tool['function']['parameters'])
+                    formatted_tools.append(fixed_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']}")
+                            # Fix array schemas in the tool parameters
+                            fixed_tool = subtool.copy()
+                            if 'parameters' in fixed_tool['function']:
+                                fixed_tool['function']['parameters'] = self._fix_array_schemas(fixed_tool['function']['parameters'])
+                            formatted_tools.append(fixed_tool)
+                        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 +553,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 +1284,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 +2086,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
@@ -2177,7 +2201,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             "function": {
                 "name": function_name,
                 "description": docstring.split('\n\n')[0] if docstring else "No description available",
-                "parameters": parameters
+                "parameters": self._fix_array_schemas(parameters)
             }
         }
         logging.debug(f"Generated tool definition: {tool_def}")

src/praisonai-agents/pyproject.toml

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

src/praisonai-agents/uv.lock

@@ -2375,7 +2375,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.112"
+version = "0.0.116"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.39.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.39.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.43.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.43.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.2.39 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.43 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.39"
+version = "2.2.43"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.112",
+    "praisonaiagents>=0.0.116",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -95,7 +95,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.39"
+version = "2.2.43"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -113,7 +113,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.112"
+praisonaiagents = ">=0.0.116"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

src/praisonai/tests/test_phase2_refactor.py

@@ -2,7 +2,13 @@
 """Test script to verify Phase 2 refactoring maintains backward compatibility"""
 
 import asyncio
-from src.praisonai_agents.praisonaiagents.llm.llm import LLM
+import sys
+import os
+
+# Add the correct path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src/praisonai-agents'))
+
+from praisonaiagents.llm import LLM
 
 def test_sync_methods():
     """Test synchronous methods still work correctly"""

src/praisonai/tests/unit/test_agent_refactor.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+Test script to verify Phase 1 refactoring of agent.py
+Tests backward compatibility and ensures no features are missing
+"""
+
+import asyncio
+import copy
+import logging
+from typing import Dict, Any
+
+# Set up logging to see debug output
+logging.basicConfig(level=logging.DEBUG)
+
+# Mock imports for testing
+class MockAgent:
+    """Mock Agent class to test the helper methods"""
+    
+    def __init__(self):
+        self.name = "TestAgent"
+        self.role = "Test Role"
+        self.goal = "Test Goal"
+        self.backstory = "Test Backstory"
+        self.use_system_prompt = True
+        self.chat_history = []
+        self.tools = []
+        self.verbose = True
+        self.markdown = False
+        
+    def _generate_tool_definition(self, tool_name):
+        """Mock tool definition generator"""
+        return {
+            "type": "function",
+            "function": {
+                "name": tool_name,
+                "description": f"Mock tool: {tool_name}",
+                "parameters": {"type": "object", "properties": {}}
+            }
+        }
+        
+    def _build_messages(self, prompt, temperature=0.2, output_json=None, output_pydantic=None):
+        """Test implementation of _build_messages helper"""
+        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:
+                import json
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps({'test': 'schema'})}"
+            elif output_pydantic:
+                import json
+                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps({'test': '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):
+            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):
+        """Test implementation of _format_tools_for_completion helper"""
+        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':
+                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':
+                        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
+            elif hasattr(tool, "to_openai_tool"):
+                formatted_tools.append(tool.to_openai_tool())
+            # 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
+        if formatted_tools:
+            try:
+                import json
+                json.dumps(formatted_tools)
+            except (TypeError, ValueError) as e:
+                logging.error(f"Tools are not JSON serializable: {e}")
+                return []
+                
+        return formatted_tools
+
+
+def test_build_messages():
+    """Test the _build_messages helper method"""
+    print("\n=== Testing _build_messages ===")
+    
+    agent = MockAgent()
+    
+    # Test 1: Simple string prompt
+    messages, original = agent._build_messages("Hello world")
+    assert len(messages) == 2  # system + user
+    assert messages[0]["role"] == "system"
+    assert messages[1]["role"] == "user"
+    assert messages[1]["content"] == "Hello world"
+    assert original == "Hello world"
+    print("✓ Simple string prompt")
+    
+    # Test 2: With chat history
+    agent.chat_history = [
+        {"role": "user", "content": "Previous message"},
+        {"role": "assistant", "content": "Previous response"}
+    ]
+    messages, original = agent._build_messages("New message")
+    assert len(messages) == 4  # system + history + user
+    assert messages[1]["content"] == "Previous message"
+    assert messages[2]["content"] == "Previous response"
+    print("✓ With chat history")
+    
+    # Test 3: JSON output modification
+    messages, original = agent._build_messages("Get data", output_json=True)
+    assert "Return ONLY a valid JSON object" in messages[-1]["content"]
+    assert original == "Get data"
+    print("✓ JSON output modification")
+    
+    # Test 4: Multimodal prompt
+    multimodal_prompt = [
+        {"type": "text", "text": "What's in this image?"},
+        {"type": "image_url", "image_url": {"url": "http://example.com/image.jpg"}}
+    ]
+    messages, original = agent._build_messages(multimodal_prompt)
+    assert isinstance(messages[-1]["content"], list)
+    assert messages[-1]["content"][0]["type"] == "text"
+    print("✓ Multimodal prompt")
+    
+    # Test 5: No system prompt
+    agent.use_system_prompt = False
+    messages, original = agent._build_messages("Hello")
+    assert messages[0]["role"] != "system"  # Should start with history or user
+    print("✓ No system prompt")
+    
+    print("\nAll _build_messages tests passed! ✅")
+
+
+def test_format_tools():
+    """Test the _format_tools_for_completion helper method"""
+    print("\n=== Testing _format_tools_for_completion ===")
+    
+    agent = MockAgent()
+    
+    # Test 1: No tools
+    result = agent._format_tools_for_completion()
+    assert result == []
+    print("✓ No tools")
+    
+    # Test 2: String tool names
+    result = agent._format_tools_for_completion(["tool1", "tool2"])
+    assert len(result) == 2
+    assert result[0]["function"]["name"] == "tool1"
+    assert result[1]["function"]["name"] == "tool2"
+    print("✓ String tool names")
+    
+    # Test 3: Pre-formatted OpenAI tools
+    openai_tool = {
+        "type": "function",
+        "function": {
+            "name": "openai_tool",
+            "description": "A pre-formatted tool",
+            "parameters": {}
+        }
+    }
+    result = agent._format_tools_for_completion([openai_tool])
+    assert len(result) == 1
+    assert result[0] == openai_tool
+    print("✓ Pre-formatted OpenAI tools")
+    
+    # Test 4: Mixed tool types
+    def my_function():
+        """A test function"""
+        pass
+    
+    mixed_tools = [
+        "string_tool",
+        openai_tool,
+        my_function
+    ]
+    result = agent._format_tools_for_completion(mixed_tools)
+    assert len(result) == 3
+    assert result[0]["function"]["name"] == "string_tool"
+    assert result[1] == openai_tool
+    assert result[2]["function"]["name"] == "my_function"
+    print("✓ Mixed tool types")
+    
+    # Test 5: Nested list of tools
+    nested_tools = [
+        [openai_tool, openai_tool],
+        "another_tool"
+    ]
+    result = agent._format_tools_for_completion(nested_tools)
+    assert len(result) == 3  # 2 from list + 1 string
+    print("✓ Nested list of tools")
+    
+    # Test 6: Invalid tools
+    invalid_tool = {
+        "type": "function",
+        # Missing 'function' key
+    }
+    result = agent._format_tools_for_completion([invalid_tool, "valid_tool"])
+    assert len(result) == 1  # Only valid_tool
+    assert result[0]["function"]["name"] == "valid_tool"
+    print("✓ Invalid tools filtered out")
+    
+    # Test 7: Using agent's default tools
+    agent.tools = ["default_tool1", "default_tool2"]
+    result = agent._format_tools_for_completion()
+    assert len(result) == 2
+    assert result[0]["function"]["name"] == "default_tool1"
+    print("✓ Using agent's default tools")
+    
+    print("\nAll _format_tools_for_completion tests passed! ✅")
+
+
+def test_backward_compatibility():
+    """Test that the refactoring maintains backward compatibility"""
+    print("\n=== Testing Backward Compatibility ===")
+    
+    agent = MockAgent()
+    
+    # Test various prompt formats still work
+    test_cases = [
+        # Simple cases
+        ("string prompt", None, None),
+        ("prompt with tools", ["tool1"], None),
+        ("json output", None, True),
+        
+        # Complex cases
+        ([{"type": "text", "text": "multimodal"}], ["tool2"], None),
+        ("mixed", ["tool1", {"type": "function", "function": {"name": "t2", "description": "test"}}], True),
+    ]
+    
+    for prompt, tools, output_json in test_cases:
+        try:
+            messages, original = agent._build_messages(prompt, output_json=output_json)
+            formatted_tools = agent._format_tools_for_completion(tools)
+            
+            # Basic validation
+            assert len(messages) >= 1
+            if tools:
+                assert len(formatted_tools) >= 1
+                
+            print(f"✓ Test case: {str(prompt)[:30]}...")
+        except Exception as e:
+            print(f"✗ Test case failed: {str(prompt)[:30]}... - {e}")
+            raise
+    
+    print("\nAll backward compatibility tests passed! ✅")
+
+
+def main():
+    """Run all tests"""
+    print("Testing Phase 1 Refactoring of agent.py")
+    print("=" * 50)
+    
+    try:
+        test_build_messages()
+        test_format_tools()
+        test_backward_compatibility()
+        
+        print("\n" + "=" * 50)
+        print("✅ ALL TESTS PASSED! The refactoring is working correctly.")
+        print("\nSummary:")
+        print("- _build_messages() helper correctly builds message arrays")
+        print("- _format_tools_for_completion() handles all tool formats")
+        print("- Backward compatibility is maintained")
+        print("- No features are missing")
+        
+    except Exception as e:
+        print(f"\n❌ TEST FAILED: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

src/praisonai/tests/unit/test_async_tool_formats.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Test script to verify async method supports all tool formats after refactoring.
+Tests sync vs async parity for all tool format types.
+"""
+import os
+import sys
+import asyncio
+from typing import Dict, List, Optional
+
+# Add the source directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../../praisonai-agents'))
+
+from praisonaiagents.llm import LLM
+
+# Test function 1: Simple callable
+def search_tool(query: str) -> str:
+    """Search for information."""
+    return f"Search results for: {query}"
+
+# Test function 2: Complex types
+def complex_tool(data: Dict[str, int], items: List[str], optional: Optional[str] = None) -> Dict:
+    """Process complex data types."""
+    return {"processed": True, "item_count": len(items)}
+
+# Pre-formatted OpenAI tool (simulating MCP.to_openai_tool() output)
+pre_formatted_tool = {
+    "type": "function",
+    "function": {
+        "name": "weather_tool",
+        "description": "Get weather information",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string", "description": "City name"},
+                "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
+            },
+            "required": ["location"]
+        }
+    }
+}
+
+# List of pre-formatted tools
+tool_list = [
+    pre_formatted_tool,
+    {
+        "type": "function",
+        "function": {
+            "name": "calculator",
+            "description": "Perform calculations",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "expression": {"type": "string"}
+                },
+                "required": ["expression"]
+            }
+        }
+    }
+]
+
+def test_sync_tool_formatting():
+    """Test sync method tool formatting."""
+    print("\n=== Testing Sync Tool Formatting ===")
+    
+    # Use a dummy model that doesn't require actual API calls
+    llm = LLM(model="openai/gpt-3.5-turbo", api_key="test")
+    
+    # Test 1: Callable tools
+    print("\n1. Testing callable tools...")
+    formatted = llm._format_tools_for_litellm([search_tool, complex_tool])
+    assert formatted is not None
+    assert len(formatted) == 2
+    assert formatted[0]["function"]["name"] == "search_tool"
+    assert formatted[1]["function"]["name"] == "complex_tool"
+    print("✓ Callable tools formatted correctly")
+    
+    # Test 2: Pre-formatted tools
+    print("\n2. Testing pre-formatted tools...")
+    formatted = llm._format_tools_for_litellm([pre_formatted_tool])
+    assert formatted is not None
+    assert len(formatted) == 1
+    assert formatted[0]["function"]["name"] == "weather_tool"
+    print("✓ Pre-formatted tools passed through correctly")
+    
+    # Test 3: List of tools
+    print("\n3. Testing list of tools...")
+    formatted = llm._format_tools_for_litellm([tool_list])
+    assert formatted is not None
+    assert len(formatted) == 2
+    assert formatted[0]["function"]["name"] == "weather_tool"
+    assert formatted[1]["function"]["name"] == "calculator"
+    print("✓ Tool lists flattened correctly")
+    
+    # Test 4: String tool names
+    print("\n4. Testing string tool names...")
+    # This would need the function to exist in globals
+    globals()['test_string_tool'] = search_tool
+    formatted = llm._format_tools_for_litellm(['test_string_tool'])
+    if formatted:  # May not work without proper setup
+        print("✓ String tool names resolved")
+    else:
+        print("⚠ String tool names need proper global setup")
+    
+    # Test 5: Mixed formats
+    print("\n5. Testing mixed tool formats...")
+    mixed_tools = [
+        search_tool,           # Callable
+        pre_formatted_tool,    # Pre-formatted
+        tool_list,            # List
+    ]
+    formatted = llm._format_tools_for_litellm(mixed_tools)
+    assert formatted is not None
+    assert len(formatted) >= 3  # At least 3 tools
+    print("✓ Mixed formats handled correctly")
+    
+    return True
+
+async def test_async_tool_formatting():
+    """Test async method tool formatting."""
+    print("\n=== Testing Async Tool Formatting ===")
+    
+    # Use a dummy model
+    llm = LLM(model="openai/gpt-3.5-turbo", api_key="test")
+    
+    # Test 1: Callable tools (previously the only supported format)
+    print("\n1. Testing callable tools...")
+    formatted = llm._format_tools_for_litellm([search_tool, complex_tool])
+    assert formatted is not None
+    assert len(formatted) == 2
+    print("✓ Callable tools formatted correctly")
+    
+    # Test 2: Pre-formatted tools (NEW - previously unsupported)
+    print("\n2. Testing pre-formatted tools...")
+    formatted = llm._format_tools_for_litellm([pre_formatted_tool])
+    assert formatted is not None
+    assert len(formatted) == 1
+    assert formatted[0]["function"]["name"] == "weather_tool"
+    print("✓ Pre-formatted tools NOW SUPPORTED! ✅")
+    
+    # Test 3: List of tools (NEW - previously unsupported)
+    print("\n3. Testing list of tools...")
+    formatted = llm._format_tools_for_litellm([tool_list])
+    assert formatted is not None
+    assert len(formatted) == 2
+    print("✓ Tool lists NOW SUPPORTED! ✅")
+    
+    # Test 4: Mixed formats (NEW capability)
+    print("\n4. Testing mixed tool formats...")
+    mixed_tools = [
+        search_tool,
+        pre_formatted_tool,
+        tool_list,
+    ]
+    formatted = llm._format_tools_for_litellm(mixed_tools)
+    assert formatted is not None
+    assert len(formatted) >= 3
+    print("✓ Mixed formats NOW SUPPORTED! ✅")
+    
+    return True
+
+def compare_implementations():
+    """Compare sync and async implementations."""
+    print("\n=== Comparing Sync vs Async ===")
+    
+    llm = LLM(model="openai/gpt-3.5-turbo", api_key="test")
+    
+    test_tools = [
+        search_tool,
+        pre_formatted_tool,
+        tool_list,
+    ]
+    
+    # Format with the shared helper (used by both sync and async now)
+    formatted = llm._format_tools_for_litellm(test_tools)
+    
+    print(f"\nTotal tools formatted: {len(formatted) if formatted else 0}")
+    print("\nFormatted tools:")
+    if formatted:
+        for tool in formatted:
+            print(f"  - {tool['function']['name']}: {tool['function']['description']}")
+    
+    print("\n✅ Both sync and async now use the SAME formatting logic!")
+    print("✅ Async now supports ALL tool formats that sync supports!")
+
+def main():
+    """Run all tests."""
+    print("Testing Async Tool Format Support")
+    print("=" * 50)
+    
+    try:
+        # Test sync formatting
+        test_sync_tool_formatting()
+        
+        # Test async formatting  
+        asyncio.run(test_async_tool_formatting())
+        
+        # Compare implementations
+        compare_implementations()
+        
+        print("\n" + "=" * 50)
+        print("✅ ALL TESTS PASSED!")
+        print("\nSummary of changes:")
+        print("- Created _format_tools_for_litellm() helper method")
+        print("- Async now supports pre-formatted tools ✅")
+        print("- Async now supports lists of tools ✅")
+        print("- Async now supports string tool names ✅")
+        print("- Removed ~95 lines of duplicate code")
+        print("- Zero breaking changes - all existing functionality preserved")
+        
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    exit(main())

src/praisonai/tests/unit/test_openai_refactor.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the OpenAI refactoring maintains backward compatibility.
+
+This script tests:
+1. OpenAI client initialization
+2. Basic agent functionality
+3. Sync and async operations
+4. Tool calling capabilities
+5. Reflection functionality
+"""
+
+import asyncio
+import os
+import sys
+
+# Add the source directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src/praisonai-agents'))
+
+from praisonaiagents.agent import Agent
+from praisonaiagents.llm import OpenAIClient, get_openai_client
+
+
+def test_openai_client():
+    """Test the OpenAI client module"""
+    print("Testing OpenAI Client Module...")
+    
+    try:
+        # Test 1: Get global client
+        client = get_openai_client()
+        print("✅ Global OpenAI client created successfully")
+        
+        # Test 2: Create new client instance
+        new_client = OpenAIClient()
+        print("✅ New OpenAI client instance created successfully")
+        
+        # Test 3: Verify sync client property
+        sync_client = client.sync_client
+        print(f"✅ Sync client type: {type(sync_client).__name__}")
+        
+        # Test 4: Verify async client property
+        async_client = client.async_client
+        print(f"✅ Async client type: {type(async_client).__name__}")
+        
+        print("\n✅ OpenAI Client Module tests passed!\n")
+        return True
+        
+    except Exception as e:
+        print(f"❌ OpenAI Client Module test failed: {e}")
+        return False
+
+
+def test_agent_initialization():
+    """Test agent initialization with OpenAI client"""
+    print("Testing Agent Initialization...")
+    
+    try:
+        # Test basic agent creation
+        agent = Agent(
+            name="Test Agent",
+            role="Assistant",
+            goal="Help with testing",
+            backstory="I am a test agent"
+        )
+        print("✅ Agent created successfully")
+        
+        # Verify OpenAI client is initialized
+        if hasattr(agent, '_openai_client'):
+            print("✅ Agent has _openai_client attribute")
+        else:
+            print("❌ Agent missing _openai_client attribute")
+            return False
+            
+        # Test agent with custom base_url
+        custom_agent = Agent(
+            name="Custom Agent",
+            role="Assistant",
+            goal="Test custom endpoint",
+            base_url="http://localhost:1234/v1"
+        )
+        print("✅ Agent with custom base_url created successfully")
+        
+        print("\n✅ Agent Initialization tests passed!\n")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Agent Initialization test failed: {e}")
+        return False
+
+
+def test_dataclasses():
+    """Test the dataclasses used for OpenAI responses"""
+    print("Testing Dataclasses...")
+    
+    try:
+        from praisonaiagents.agent.agent import (
+            ChatCompletionMessage, 
+            Choice, 
+            ChatCompletion,
+            ToolCall
+        )
+        
+        # Test ToolCall creation
+        tool_call = ToolCall(
+            id="test_id",
+            type="function",
+            function={"name": "test_function", "arguments": "{}"}
+        )
+        print(f"✅ ToolCall created: {tool_call}")
+        
+        # Test ChatCompletionMessage
+        message = ChatCompletionMessage(
+            content="Test message",
+            role="assistant",
+            tool_calls=[tool_call]
+        )
+        print("✅ ChatCompletionMessage created successfully")
+        
+        # Test Choice
+        choice = Choice(
+            finish_reason="stop",
+            index=0,
+            message=message
+        )
+        print("✅ Choice created successfully")
+        
+        # Test ChatCompletion
+        completion = ChatCompletion(
+            id="test_completion",
+            choices=[choice],
+            created=1234567890,
+            model="gpt-4"
+        )
+        print("✅ ChatCompletion created successfully")
+        
+        print("\n✅ Dataclasses tests passed!\n")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Dataclasses test failed: {e}")
+        return False
+
+
+async def test_async_functionality():
+    """Test async functionality"""
+    print("Testing Async Functionality...")
+    
+    try:
+        agent = Agent(
+            name="Async Test Agent",
+            role="Assistant",
+            goal="Test async operations",
+            verbose=False
+        )
+        
+        # Note: We can't actually call the API without valid credentials
+        # But we can verify the methods exist and are callable
+        
+        # Check if achat method exists
+        if hasattr(agent, 'achat'):
+            print("✅ Agent has achat method")
+        else:
+            print("❌ Agent missing achat method")
+            return False
+            
+        # Check if _achat_completion exists
+        if hasattr(agent, '_achat_completion'):
+            print("✅ Agent has _achat_completion method")
+        else:
+            print("❌ Agent missing _achat_completion method")
+            return False
+            
+        print("\n✅ Async Functionality tests passed!\n")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Async Functionality test failed: {e}")
+        return False
+
+
+def main():
+    """Run all tests"""
+    print("=" * 60)
+    print("OpenAI Refactoring Test Suite")
+    print("=" * 60)
+    print()
+    
+    results = []
+    
+    # Run sync tests
+    results.append(test_openai_client())
+    results.append(test_agent_initialization())
+    results.append(test_dataclasses())
+    
+    # Run async tests
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    results.append(loop.run_until_complete(test_async_functionality()))
+    
+    # Summary
+    print("=" * 60)
+    print("Test Summary")
+    print("=" * 60)
+    
+    passed = sum(results)
+    total = len(results)
+    
+    print(f"\nTests passed: {passed}/{total}")
+    
+    if passed == total:
+        print("\n✅ All tests passed! The refactoring maintains backward compatibility.")
+        return 0
+    else:
+        print(f"\n❌ {total - passed} tests failed. Please review the failures above.")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/praisonai/tests/unit/test_openai_refactor_2.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the OpenAI refactoring works correctly.
+"""
+
+import asyncio
+from praisonaiagents import Agent
+from praisonaiagents.llm import (
+    get_openai_client,
+    ChatCompletionMessage,
+    Choice,
+    CompletionUsage,
+    ChatCompletion,
+    ToolCall,
+    process_stream_chunks
+)
+
+def test_data_classes():
+    """Test that data classes are properly imported and work"""
+    print("Testing data classes...")
+    
+    # Create a message
+    msg = ChatCompletionMessage(
+        content="Hello, world!",
+        role="assistant"
+    )
+    assert msg.content == "Hello, world!"
+    assert msg.role == "assistant"
+    print("✓ ChatCompletionMessage works")
+    
+    # Create a choice
+    choice = Choice(
+        finish_reason="stop",
+        index=0,
+        message=msg
+    )
+    assert choice.finish_reason == "stop"
+    assert choice.message.content == "Hello, world!"
+    print("✓ Choice works")
+    
+    # Create a tool call
+    tool_call = ToolCall(
+        id="call_123",
+        type="function",
+        function={"name": "test_tool", "arguments": "{}"}
+    )
+    assert tool_call.id == "call_123"
+    assert tool_call.function["name"] == "test_tool"
+    print("✓ ToolCall works")
+    
+    print("All data classes test passed!\n")
+
+def test_openai_client():
+    """Test that OpenAI client is properly initialized"""
+    print("Testing OpenAI client...")
+    
+    try:
+        # This might fail if OPENAI_API_KEY is not set, which is OK for testing
+        client = get_openai_client()
+        print("✓ OpenAI client created successfully")
+        
+        # Test build_messages method
+        messages, original = client.build_messages(
+            prompt="Test prompt",
+            system_prompt="You are a helpful assistant"
+        )
+        assert len(messages) == 2
+        assert messages[0]["role"] == "system"
+        assert messages[1]["role"] == "user"
+        print("✓ build_messages method works")
+        
+        # Test format_tools method (with no tools)
+        tools = client.format_tools(None)
+        assert tools is None
+        print("✓ format_tools method works")
+        
+    except ValueError as e:
+        if "OPENAI_API_KEY" in str(e):
+            print("⚠ OpenAI client requires API key (expected in test environment)")
+        else:
+            raise
+    
+    print("OpenAI client tests completed!\n")
+
+def test_agent_integration():
+    """Test that Agent class works with the refactored code"""
+    print("Testing Agent integration...")
+    
+    try:
+        # Create a simple agent
+        agent = Agent(
+            name="Test Agent",
+            role="Tester",
+            goal="Test the refactored code",
+            instructions="You are a test agent"
+        )
+        print("✓ Agent created successfully")
+        
+        # Test _build_messages
+        messages, original = agent._build_messages(
+            prompt="Test prompt",
+            temperature=0.5
+        )
+        assert len(messages) >= 1
+        assert messages[-1]["content"] == "Test prompt"
+        print("✓ Agent._build_messages works")
+        
+        # Test _format_tools_for_completion
+        def sample_tool():
+            """A sample tool for testing"""
+            pass
+        
+        formatted = agent._format_tools_for_completion([sample_tool])
+        assert isinstance(formatted, list)
+        print("✓ Agent._format_tools_for_completion works")
+        
+    except Exception as e:
+        print(f"⚠ Agent integration test failed: {e}")
+        # This is OK if dependencies are missing
+    
+    print("Agent integration tests completed!\n")
+
+async def test_async_functionality():
+    """Test async functionality"""
+    print("Testing async functionality...")
+    
+    try:
+        client = get_openai_client()
+        
+        # Test that async client can be accessed
+        async_client = client.async_client
+        print("✓ Async client accessible")
+        
+        # Test build_messages (which is sync but used in async context)
+        messages, _ = client.build_messages("Test async")
+        assert len(messages) >= 1
+        print("✓ build_messages works in async context")
+        
+    except ValueError as e:
+        if "OPENAI_API_KEY" in str(e):
+            print("⚠ Async tests require API key")
+        else:
+            raise
+    
+    print("Async functionality tests completed!\n")
+
+def main():
+    """Run all tests"""
+    print("=" * 50)
+    print("OpenAI Refactoring Test Suite")
+    print("=" * 50)
+    print()
+    
+    # Run sync tests
+    test_data_classes()
+    test_openai_client()
+    test_agent_integration()
+    
+    # Run async tests
+    asyncio.run(test_async_functionality())
+    
+    print("=" * 50)
+    print("All tests completed!")
+    print("=" * 50)
+
+if __name__ == "__main__":
+    main()

src/praisonai/uv.lock

@@ -3931,7 +3931,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.2.39"
+version = "2.2.43"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -4073,7 +4073,7 @@ requires-dist = [
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.15" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.15" },
-    { name = "praisonaiagents", specifier = ">=0.0.112" },
+    { name = "praisonaiagents", specifier = ">=0.0.116" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4130,7 +4130,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.112"
+version = "0.0.116"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mcp" },
@@ -4139,9 +4139,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b8/f0/f03a2e64ee0f78824a78275b8a2350f2086a37dd75601b43e740f7a55c3b/praisonaiagents-0.0.112.tar.gz", hash = "sha256:504efc8a427b80a2e4865831c651c834239fb33b7766792e2f3d1157518ac09a", size = 166924 }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/3b/61a7b4b57817b2d5eabdac89df126ef39ba06c7a43d7b17786d7d6882f44/praisonaiagents-0.0.116.tar.gz", hash = "sha256:6e5de5ece6c2550fee9a59cf3d0c9a8da09cd22acfaf8037873b7649493962ca", size = 172642 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f8/da/83271d3671e468f855e225c9c23fe19b7a5be654ab8f8b0fc305bf1b10f1/praisonaiagents-0.0.112-py3-none-any.whl", hash = "sha256:b402af5eb7e3ffca702aeae89ca01f8f4c223aa194b743a3d9d1feb71e5efd6e", size = 186397 },
+    { url = "https://files.pythonhosted.org/packages/21/4f/5fbe1e129f5b0ab7386e17dbb4f7cc97ec896291db82b601605d4721616d/praisonaiagents-0.0.116-py3-none-any.whl", hash = "sha256:2449de40da7653100b247c3338afe0dcde3b0dc4227c3edd0111e24b4f5083ab", size = 193268 },
 ]
 
 [[package]]