praisonaiagents 0.0.116__tar.gz → 0.0.118__tar.gz

{praisonaiagents-0.0.116 → praisonaiagents-0.0.118}/PKG-INFO

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

{praisonaiagents-0.0.116 → praisonaiagents-0.0.118}/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.116 → praisonaiagents-0.0.118}/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.116 → praisonaiagents-0.0.118}/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.116 → praisonaiagents-0.0.118}/praisonaiagents/llm/llm.py

@@ -813,99 +813,56 @@ class LLM:
                         # Make one more call to get the final summary response
                         # Special handling for Ollama models that don't automatically process tool results
                         ollama_handled = False
-                        if self.model and self.model.startswith("ollama/") and tool_results:
-                            # For Ollama models, we need to explicitly ask the model to process the tool results
-                            # First, check if the response is just a JSON tool call
-                            try:
-                                # If the response_text is a valid JSON that looks like a tool call,
-                                # we need to make a follow-up call to process the results
-                                json_response = json.loads(response_text.strip())
-                                if ('name' in json_response or 'function' in json_response) and not any(word in response_text.lower() for word in ['summary', 'option', 'result', 'found']):
-                                    logging.debug("Detected Ollama returning only tool call JSON, making follow-up call to process results")
-                                    
-                                    # Create a prompt that asks the model to process the tool results based on original context
-                                    # Extract the original user query from messages
-                                    original_query = ""
-                                    for msg in reversed(messages):  # Look from the end to find the most recent user message
-                                        if msg.get("role") == "user":
-                                            content = msg.get("content", "")
-                                            # Handle list content (multimodal)
-                                            if isinstance(content, list):
-                                                for item in content:
-                                                    if isinstance(item, dict) and item.get("type") == "text":
-                                                        original_query = item.get("text", "")
-                                                        break
-                                            else:
-                                                original_query = content
-                                            if original_query:
-                                                break
-                                    
-                                    # Create a shorter follow-up prompt with all tool results
-                                    # If there's only one result, use it directly; otherwise combine them
-                                    if len(tool_results) == 1:
-                                        results_text = json.dumps(tool_results[0], indent=2)
-                                    else:
-                                        results_text = json.dumps(tool_results, indent=2)
-                                    
-                                    follow_up_prompt = f"Results:\n{results_text}\nProvide Answer to this Original Question based on the above results: '{original_query}'"
-                                    logging.debug(f"[OLLAMA_DEBUG] Original query extracted: {original_query}")
-                                    logging.debug(f"[OLLAMA_DEBUG] Follow-up prompt: {follow_up_prompt[:200]}...")
-                                    
-                                    # Make a follow-up call to process the results
-                                    follow_up_messages = [
-                                        {"role": "user", "content": follow_up_prompt}
-                                    ]
-                                    
-                                    # Get response with streaming
-                                    if verbose:
-                                        with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
-                                            response_text = ""
-                                            for chunk in litellm.completion(
-                                                **self._build_completion_params(
-                                                    messages=follow_up_messages,
-                                                    temperature=temperature,
-                                                    stream=stream
-                                                )
-                                            ):
-                                                if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                                    content = chunk.choices[0].delta.content
-                                                    response_text += content
-                                                    live.update(display_generating(response_text, start_time))
-                                    else:
-                                        response_text = ""
-                                        for chunk in litellm.completion(
-                                            **self._build_completion_params(
-                                                messages=follow_up_messages,
-                                                temperature=temperature,
-                                                stream=stream
-                                            )
-                                        ):
-                                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                                response_text += chunk.choices[0].delta.content
-                                    
-                                    # Set flag to indicate Ollama was handled
-                                    ollama_handled = True
-                                    final_response_text = response_text.strip()
-                                    logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
-                                    
-                                    # Display the response if we got one
-                                    if final_response_text and verbose:
-                                        display_interaction(
-                                            original_prompt,
-                                            final_response_text,
-                                            markdown=markdown,
-                                            generation_time=time.time() - start_time,
-                                            console=console
+                        ollama_params = self._handle_ollama_model(response_text, tool_results, messages, original_prompt)
+                        
+                        if ollama_params:
+                            # Get response with streaming
+                            if verbose:
+                                with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
+                                    response_text = ""
+                                    for chunk in litellm.completion(
+                                        **self._build_completion_params(
+                                            messages=ollama_params["follow_up_messages"],
+                                            temperature=temperature,
+                                            stream=stream
                                         )
-                                    
-                                    # Return the final response after processing Ollama's follow-up
-                                    if final_response_text:
-                                        return final_response_text
-                                    else:
-                                        logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
-                            except (json.JSONDecodeError, KeyError):
-                                # Not a JSON response or not a tool call format, continue normally
-                                pass
+                                    ):
+                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                            content = chunk.choices[0].delta.content
+                                            response_text += content
+                                            live.update(display_generating(response_text, start_time))
+                            else:
+                                response_text = ""
+                                for chunk in litellm.completion(
+                                    **self._build_completion_params(
+                                        messages=ollama_params["follow_up_messages"],
+                                        temperature=temperature,
+                                        stream=stream
+                                    )
+                                ):
+                                    if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                        response_text += chunk.choices[0].delta.content
+                            
+                            # Set flag to indicate Ollama was handled
+                            ollama_handled = True
+                            final_response_text = response_text.strip()
+                            logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
+                            
+                            # Display the response if we got one
+                            if final_response_text and verbose:
+                                display_interaction(
+                                    ollama_params["original_prompt"],
+                                    final_response_text,
+                                    markdown=markdown,
+                                    generation_time=time.time() - start_time,
+                                    console=console
+                                )
+                            
+                            # Return the final response after processing Ollama's follow-up
+                            if final_response_text:
+                                return final_response_text
+                            else:
+                                logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
                         
                         # If reasoning_steps is True and we haven't handled Ollama already, do a single non-streaming call
                         if reasoning_steps and not ollama_handled:
@@ -1480,99 +1437,56 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     
                     # Special handling for Ollama models that don't automatically process tool results
                     ollama_handled = False
-                    if self._is_ollama_provider() and tool_results:
-                        # For Ollama models, we need to explicitly ask the model to process the tool results
-                        # First, check if the response is just a JSON tool call
-                        try:
-                            # If the response_text is a valid JSON that looks like a tool call,
-                            # we need to make a follow-up call to process the results
-                            json_response = json.loads(response_text.strip())
-                            if ('name' in json_response or 'function' in json_response) and not any(word in response_text.lower() for word in ['summary', 'option', 'result', 'found']):
-                                logging.debug("Detected Ollama returning only tool call JSON in async mode, making follow-up call to process results")
-                                
-                                # Create a prompt that asks the model to process the tool results based on original context
-                                # Extract the original user query from messages
-                                original_query = ""
-                                for msg in reversed(messages):  # Look from the end to find the most recent user message
-                                    if msg.get("role") == "user":
-                                        content = msg.get("content", "")
-                                        # Handle list content (multimodal)
-                                        if isinstance(content, list):
-                                            for item in content:
-                                                if isinstance(item, dict) and item.get("type") == "text":
-                                                    original_query = item.get("text", "")
-                                                    break
-                                        else:
-                                            original_query = content
-                                        if original_query:
-                                            break
-                                
-                                # Create a shorter follow-up prompt with all tool results
-                                # If there's only one result, use it directly; otherwise combine them
-                                if len(tool_results) == 1:
-                                    results_text = json.dumps(tool_results[0], indent=2)
-                                else:
-                                    results_text = json.dumps(tool_results, indent=2)
-                                
-                                follow_up_prompt = f"Results:\n{results_text}\nProvide Answer to this Original Question based on the above results: '{original_query}'"
-                                logging.debug(f"[OLLAMA_DEBUG] Original query extracted: {original_query}")
-                                logging.debug(f"[OLLAMA_DEBUG] Follow-up prompt: {follow_up_prompt[:200]}...")
-                                
-                                # Make a follow-up call to process the results
-                                follow_up_messages = [
-                                    {"role": "user", "content": follow_up_prompt}
-                                ]
-                                
-                                # Get response with streaming
-                                if verbose:
-                                    response_text = ""
-                                    async for chunk in await litellm.acompletion(
-                                        **self._build_completion_params(
-                                            messages=follow_up_messages,
-                                            temperature=temperature,
-                                            stream=stream
-                                        )
-                                    ):
-                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            content = chunk.choices[0].delta.content
-                                            response_text += content
-                                            print("\033[K", end="\r")
-                                            print(f"Processing results... {time.time() - start_time:.1f}s", end="\r")
-                                else:
-                                    response_text = ""
-                                    async for chunk in await litellm.acompletion(
-                                        **self._build_completion_params(
-                                            messages=follow_up_messages,
-                                            temperature=temperature,
-                                            stream=stream
-                                        )
-                                    ):
-                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            response_text += chunk.choices[0].delta.content
-                                
-                                # Set flag to indicate Ollama was handled
-                                ollama_handled = True
-                                final_response_text = response_text.strip()
-                                logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
-                                
-                                # Display the response if we got one
-                                if final_response_text and verbose:
-                                    display_interaction(
-                                        original_prompt,
-                                        final_response_text,
-                                        markdown=markdown,
-                                        generation_time=time.time() - start_time,
-                                        console=console
-                                    )
-                                
-                                # Return the final response after processing Ollama's follow-up
-                                if final_response_text:
-                                    return final_response_text
-                                else:
-                                    logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
-                        except (json.JSONDecodeError, KeyError):
-                            # Not a JSON response or not a tool call format, continue normally
-                            pass
+                    ollama_params = self._handle_ollama_model(response_text, tool_results, messages, original_prompt)
+                    
+                    if ollama_params:
+                        # Get response with streaming
+                        if verbose:
+                            response_text = ""
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=ollama_params["follow_up_messages"],
+                                    temperature=temperature,
+                                    stream=stream
+                                )
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                    content = chunk.choices[0].delta.content
+                                    response_text += content
+                                    print("\033[K", end="\r")
+                                    print(f"Processing results... {time.time() - start_time:.1f}s", end="\r")
+                        else:
+                            response_text = ""
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=ollama_params["follow_up_messages"],
+                                    temperature=temperature,
+                                    stream=stream
+                                )
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                    response_text += chunk.choices[0].delta.content
+                        
+                        # Set flag to indicate Ollama was handled
+                        ollama_handled = True
+                        final_response_text = response_text.strip()
+                        logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
+                        
+                        # Display the response if we got one
+                        if final_response_text and verbose:
+                            display_interaction(
+                                ollama_params["original_prompt"],
+                                final_response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
+                        
+                        # Return the final response after processing Ollama's follow-up
+                        if final_response_text:
+                            return final_response_text
+                        else:
+                            logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
                     
                     # If no special handling was needed or if it's not an Ollama model
                     if reasoning_steps and not ollama_handled:
@@ -1839,6 +1753,68 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 
         litellm.callbacks = events
 
+    def _handle_ollama_model(self, response_text: str, tool_results: List[Any], messages: List[Dict], original_prompt: Union[str, List[Dict]]) -> Optional[Dict[str, Any]]:
+        """
+        Handle special Ollama model requirements when processing tool results.
+        
+        Args:
+            response_text: The initial response text from the model
+            tool_results: List of tool execution results
+            messages: The conversation messages list
+            original_prompt: The original user prompt
+            
+        Returns:
+            Dict with follow-up parameters if Ollama needs special handling, None otherwise
+        """
+        if not self._is_ollama_provider() or not tool_results:
+            return None
+            
+        # Check if the response is just a JSON tool call
+        try:
+            json_response = json.loads(response_text.strip())
+            if not (('name' in json_response or 'function' in json_response) and 
+                    not any(word in response_text.lower() for word in ['summary', 'option', 'result', 'found'])):
+                return None
+                
+            logging.debug("Detected Ollama returning only tool call JSON, preparing follow-up call to process results")
+            
+            # Extract the original user query from messages
+            original_query = ""
+            for msg in reversed(messages):  # Look from the end to find the most recent user message
+                if msg.get("role") == "user":
+                    content = msg.get("content", "")
+                    # Handle list content (multimodal)
+                    if isinstance(content, list):
+                        for item in content:
+                            if isinstance(item, dict) and item.get("type") == "text":
+                                original_query = item.get("text", "")
+                                break
+                    else:
+                        original_query = content
+                    if original_query:
+                        break
+            
+            # Create a shorter follow-up prompt with all tool results
+            # If there's only one result, use it directly; otherwise combine them
+            if len(tool_results) == 1:
+                results_text = json.dumps(tool_results[0], indent=2)
+            else:
+                results_text = json.dumps(tool_results, indent=2)
+            
+            follow_up_prompt = f"Results:\n{results_text}\nProvide Answer to this Original Question based on the above results: '{original_query}'"
+            logging.debug(f"[OLLAMA_DEBUG] Original query extracted: {original_query}")
+            logging.debug(f"[OLLAMA_DEBUG] Follow-up prompt: {follow_up_prompt[:200]}...")
+            
+            # Return parameters for follow-up call
+            return {
+                "follow_up_messages": [{"role": "user", "content": follow_up_prompt}],
+                "original_prompt": original_prompt
+            }
+            
+        except (json.JSONDecodeError, KeyError):
+            # Not a JSON response or not a tool call format
+            return None
+
     def _build_completion_params(self, **override_params) -> Dict[str, Any]:
         """Build parameters for litellm completion calls with all necessary config"""
         params = {

{praisonaiagents-0.0.116 → praisonaiagents-0.0.118}/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.116 → praisonaiagents-0.0.118}/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.116 → praisonaiagents-0.0.118}/praisonaiagents.egg-info/PKG-INFO

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

{praisonaiagents-0.0.116 → praisonaiagents-0.0.118}/pyproject.toml

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