praisonaiagents 0.0.115__tar.gz → 0.0.117__tar.gz

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/PKG-INFO

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

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents/agent/agent.py

@@ -354,8 +354,10 @@ class Agent:
         # 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)
+        # Store OpenAI client parameters for lazy initialization
+        self._openai_api_key = api_key
+        self._openai_base_url = base_url
+        self.__openai_client = None
 
         # If base_url is provided, always create a custom LLM instance
         if base_url:
@@ -488,6 +490,42 @@ Your Goal: {self.goal}
                 for source in knowledge:
                     self._process_knowledge(source)
 
+    @property
+    def _openai_client(self):
+        """Lazily initialize OpenAI client only when needed."""
+        if self.__openai_client is None:
+            try:
+                self.__openai_client = get_openai_client(
+                    api_key=self._openai_api_key, 
+                    base_url=self._openai_base_url
+                )
+            except ValueError as e:
+                # If we're using a custom LLM, we might not need the OpenAI client
+                # Return None and let the calling code handle it
+                if self._using_custom_llm:
+                    return None
+                else:
+                    raise e
+        return self.__openai_client
+
+    @property
+    def llm_model(self):
+        """Unified property to get the LLM model regardless of configuration type.
+        
+        Returns:
+            The LLM model/instance being used by this agent.
+            - For standard models: returns the model string (e.g., "gpt-4o")
+            - For custom LLM instances: returns the LLM instance object
+            - For provider models: returns the LLM instance object
+        """
+        if hasattr(self, 'llm_instance') and self.llm_instance:
+            return self.llm_instance
+        elif hasattr(self, 'llm') and self.llm:
+            return self.llm
+        else:
+            # Default fallback
+            return "gpt-4o"
+
     def _process_knowledge(self, knowledge_item):
         """Process and store knowledge from a file path, URL, or string."""
         try:
@@ -694,14 +732,39 @@ 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
-        )
+        # Use openai_client's build_messages method if available
+        if self._openai_client is not None:
+            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
+            )
+        else:
+            # Fallback implementation for when OpenAI client is not available
+            messages = []
+            
+            # Add system message if provided
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            
+            # Add chat history
+            messages.extend(self.chat_history)
+            
+            # Add user prompt
+            if isinstance(prompt, list):
+                messages.extend(prompt)
+                original_prompt = prompt
+            else:
+                messages.append({"role": "user", "content": str(prompt)})
+                original_prompt = str(prompt)
+            
+            # Add JSON format instruction if needed
+            if output_json or output_pydantic:
+                model = output_pydantic or output_json
+                json_instruction = f"\nPlease respond with valid JSON matching this schema: {model.model_json_schema()}"
+                messages[-1]["content"] += json_instruction
         
         return messages, original_prompt
 
@@ -943,6 +1006,9 @@ 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"""
+        if self._openai_client is None:
+            raise ValueError("OpenAI client is not initialized. Please provide OPENAI_API_KEY or use a custom LLM provider.")
+        
         return self._openai_client.process_stream_response(
             messages=messages,
             model=self.llm,
@@ -1009,6 +1075,9 @@ Your Goal: {self.goal}
                 
                 # 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
+                if self._openai_client is None:
+                    raise ValueError("OpenAI client is not initialized. Please provide OPENAI_API_KEY or use a custom LLM provider.")
+                
                 final_response = self._openai_client.chat_completion_with_tools(
                     messages=messages,
                     model=self.llm,
@@ -1202,6 +1271,17 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     messages.append({"role": "user", "content": reflection_prompt})
 
                     try:
+                        # Check if OpenAI client is available
+                        if self._openai_client is None:
+                            # For custom LLMs, self-reflection with structured output is not supported
+                            if self.verbose:
+                                display_self_reflection(f"Agent {self.name}: Self-reflection with structured output is not supported for custom LLM providers. Skipping reflection.", console=self.console)
+                            # Return the original response without reflection
+                            self.chat_history.append({"role": "user", "content": prompt})
+                            self.chat_history.append({"role": "assistant", "content": response_text})
+                            display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
+                            return response_text
+                        
                         reflection_response = self._openai_client.sync_client.beta.chat.completions.parse(
                             model=self.reflect_llm if self.reflect_llm else self.llm,
                             messages=messages,
@@ -1388,6 +1468,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
                     # Use the new _format_tools_for_completion helper method
                     formatted_tools = self._format_tools_for_completion(tools)
+                    
+                    # Check if OpenAI client is available
+                    if self._openai_client is None:
+                        error_msg = "OpenAI client is not initialized. Please provide OPENAI_API_KEY or use a custom LLM provider."
+                        display_error(error_msg)
+                        return None
 
                     # Make the API call based on the type of request
                     if tools:
@@ -1442,6 +1528,19 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 ]
                                 
                                 try:
+                                    # Check if OpenAI client is available for self-reflection
+                                    if self._openai_client is None:
+                                        # For custom LLMs, self-reflection with structured output is not supported
+                                        if self.verbose:
+                                            display_self_reflection(f"Agent {self.name}: Self-reflection with structured output is not supported for custom LLM providers. Skipping reflection.", console=self.console)
+                                        # Return the original response without reflection
+                                        self.chat_history.append({"role": "user", "content": original_prompt})
+                                        self.chat_history.append({"role": "assistant", "content": response_text})
+                                        if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+                                            total_time = time.time() - start_time
+                                            logging.debug(f"Agent.achat completed in {total_time:.2f} seconds")
+                                        return response_text
+                                    
                                     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,

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents/agents/agents.py

@@ -7,7 +7,7 @@ from pydantic import BaseModel
 from rich.text import Text
 from rich.panel import Panel
 from rich.console import Console
-from ..main import display_error, TaskOutput, error_logs, client
+from ..main import display_error, TaskOutput, error_logs
 from ..agent.agent import Agent
 from ..task.task import Task
 from ..process.process import Process, LoopItems

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents/agents/autoagents.py

@@ -12,7 +12,8 @@ from typing import List, Any, Optional, Dict, Tuple
 import logging
 import os
 from pydantic import BaseModel, ConfigDict
-from ..main import display_instruction, display_tool_call, display_interaction, client
+from ..main import display_instruction, display_tool_call, display_interaction
+from ..llm import get_openai_client
 
 # Define Pydantic models for structured output
 class TaskConfig(BaseModel):
@@ -237,6 +238,17 @@ Return the configuration in a structured JSON format matching the AutoAgentsConf
 """
         
         try:
+            # Get OpenAI client
+            try:
+                client = get_openai_client()
+            except ValueError as e:
+                # AutoAgents requires OpenAI for structured output generation
+                raise ValueError(
+                    "AutoAgents requires OpenAI API for automatic agent generation. "
+                    "Please set OPENAI_API_KEY environment variable or use PraisonAIAgents class directly "
+                    "with manually configured agents for non-OpenAI providers."
+                ) from e
+                
             response = client.beta.chat.completions.parse(
                 model=self.llm,
                 response_format=AutoAgentsConfig,

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents/llm/llm.py

@@ -364,6 +364,46 @@ 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.
         
@@ -389,7 +429,11 @@ class LLM:
                 # Validate nested dictionary structure before accessing
                 if 'function' in tool and isinstance(tool['function'], dict) and 'name' in tool['function']:
                     logging.debug(f"Using pre-formatted OpenAI tool: {tool['function']['name']}")
-                    formatted_tools.append(tool)
+                    # 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())
@@ -399,7 +443,11 @@ class LLM:
                         # Validate nested dictionary structure before accessing
                         if 'function' in subtool and isinstance(subtool['function'], dict) and 'name' in subtool['function']:
                             logging.debug(f"Using pre-formatted OpenAI tool from list: {subtool['function']['name']}")
-                            formatted_tools.append(subtool)
+                            # 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):
@@ -2153,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}")

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents/main.py

@@ -3,7 +3,6 @@ import time
 import json
 import logging
 from typing import List, Optional, Dict, Any, Union, Literal, Type
-from openai import OpenAI
 from pydantic import BaseModel, ConfigDict
 from rich import print
 from rich.console import Console
@@ -377,24 +376,6 @@ class ReflectionOutput(BaseModel):
     reflection: str
     satisfactory: Literal["yes", "no"]
 
-# Constants
-LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
-
-# Initialize OpenAI client with proper API key handling
-api_key = os.environ.get("OPENAI_API_KEY")
-base_url = os.environ.get("OPENAI_API_BASE") or os.environ.get("OPENAI_BASE_URL")
-
-# For local servers like LM Studio, allow minimal API key
-if base_url and not api_key:
-    api_key = LOCAL_SERVER_API_KEY_PLACEHOLDER
-elif not 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}'"
-    )
-
-client = OpenAI(api_key=api_key, base_url=base_url)
 
 class TaskOutput(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents/process/process.py

@@ -5,10 +5,10 @@ from typing import Dict, Optional, List, Any, AsyncGenerator
 from pydantic import BaseModel, ConfigDict
 from ..agent.agent import Agent
 from ..task.task import Task
-from ..main import display_error, client
+from ..main import display_error
 import csv
 import os
-from openai import AsyncOpenAI
+from openai import AsyncOpenAI, OpenAI
 
 class LoopItems(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -140,6 +140,8 @@ class Process:
 
     def _get_manager_instructions_with_fallback(self, manager_task, manager_prompt, ManagerInstructions):
         """Sync version of getting manager instructions with fallback"""
+        # Create OpenAI client
+        client = OpenAI()
         try:
             # First try structured output (OpenAI compatible)
             logging.info("Attempting structured output...")

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/praisonaiagents.egg-info/PKG-INFO

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

{praisonaiagents-0.0.115 → praisonaiagents-0.0.117}/pyproject.toml

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