praisonaiagents 0.0.130__tar.gz → 0.0.132__tar.gz

{praisonaiagents-0.0.130 → praisonaiagents-0.0.132}/PKG-INFO

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

{praisonaiagents-0.0.130 → praisonaiagents-0.0.132}/praisonaiagents/agent/agent.py

@@ -27,7 +27,8 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     adisplay_instruction,
-    approval_callback
+    approval_callback,
+    execute_sync_callback
 )
 import inspect
 import uuid
@@ -424,7 +425,13 @@ class Agent:
         # Otherwise, fall back to OpenAI environment/name
         else:
             self.llm = llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
-        self.tools = tools if tools else []  # Store original tools
+        # Handle tools parameter - ensure it's always a list
+        if callable(tools):
+            # If a single function/callable is passed, wrap it in a list
+            self.tools = [tools]
+        else:
+            # Handle all falsy values (None, False, 0, "", etc.) by defaulting to empty list
+            self.tools = tools or []
         self.function_calling_llm = function_calling_llm
         self.max_iter = max_iter
         self.max_rpm = max_rpm
@@ -1093,6 +1100,10 @@ Your Goal: {self.goal}"""
                         execute_tool_fn=self.execute_tool,
                         agent_name=self.name,
                         agent_role=self.role,
+                        agent_tools=[t.__name__ for t in self.tools] if self.tools else None,
+                        task_name=task_name,
+                        task_description=task_description,
+                        task_id=task_id,
                         reasoning_steps=reasoning_steps
                     )
                 else:
@@ -1109,6 +1120,10 @@ Your Goal: {self.goal}"""
                         execute_tool_fn=self.execute_tool,
                         agent_name=self.name,
                         agent_role=self.role,
+                        agent_tools=[t.__name__ for t in self.tools] if self.tools else None,
+                        task_name=task_name,
+                        task_description=task_description,
+                        task_id=task_id,
                         reasoning_steps=reasoning_steps
                     )
             else:
@@ -1142,8 +1157,39 @@ Your Goal: {self.goal}"""
         except Exception as e:
             display_error(f"Error in chat completion: {e}")
             return None
-
-    def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False, stream=True):
+    
+    def _execute_callback_and_display(self, prompt: str, response: str, generation_time: float):
+        """Helper method to execute callbacks and display interaction.
+        
+        This centralizes the logic for callback execution and display to avoid duplication.
+        """
+        # Always execute callbacks regardless of verbose setting (only when not using custom LLM)
+        if not self._using_custom_llm:
+            execute_sync_callback(
+                'interaction',
+                message=prompt,
+                response=response,
+                markdown=self.markdown,
+                generation_time=generation_time,
+                agent_name=self.name,
+                agent_role=self.role,
+                agent_tools=[t.__name__ for t in self.tools] if self.tools else None,
+                task_name=None,  # Not available in this context
+                task_description=None,  # Not available in this context 
+                task_id=None  # Not available in this context
+            )
+        # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
+        if self.verbose and not self._using_custom_llm:
+            display_interaction(prompt, response, markdown=self.markdown, 
+                              generation_time=generation_time, console=self.console,
+                              agent_name=self.name,
+                              agent_role=self.role,
+                              agent_tools=[t.__name__ for t in self.tools] if self.tools else None,
+                              task_name=None,  # Not available in this context
+                              task_description=None,  # Not available in this context
+                              task_id=None)  # Not available in this context
+
+    def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None, reasoning_steps=False, stream=True, task_name=None, task_description=None, task_id=None):
         # Log all parameter values when in debug mode
         if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
             param_info = {
@@ -1234,6 +1280,9 @@ Your Goal: {self.goal}"""
                     agent_name=self.name,
                     agent_role=self.role,
                     agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)],
+                    task_name=task_name,
+                    task_description=task_description,
+                    task_id=task_id,
                     execute_tool_fn=self.execute_tool,  # Pass tool execution function
                     reasoning_steps=reasoning_steps,
                     stream=stream  # Pass the stream parameter from chat method
@@ -1321,25 +1370,30 @@ Your Goal: {self.goal}"""
                             # Add to chat history and return raw response
                             # User message already added before LLM call via _build_messages
                             self.chat_history.append({"role": "assistant", "content": response_text})
-                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                            if self.verbose and not self._using_custom_llm:
-                                display_interaction(original_prompt, response_text, markdown=self.markdown, 
-                                                 generation_time=time.time() - start_time, console=self.console)
-                            return response_text
+                            # Apply guardrail validation even for JSON output
+                            try:
+                                validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                # Execute callback after validation
+                                self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
+                                return validated_response
+                            except Exception as e:
+                                logging.error(f"Agent {self.name}: Guardrail validation failed for JSON output: {e}")
+                                # Rollback chat history on guardrail failure
+                                self.chat_history = self.chat_history[:chat_history_length]
+                                return None
 
                         if not self.self_reflect:
                             # User message already added before LLM call via _build_messages
                             self.chat_history.append({"role": "assistant", "content": response_text})
                             if self.verbose:
                                 logging.debug(f"Agent {self.name} final response: {response_text}")
-                            # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                            if self.verbose and not self._using_custom_llm:
-                                display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                             # Return only reasoning content if reasoning_steps is True
                             if reasoning_steps and hasattr(response.choices[0].message, 'reasoning_content'):
                                 # Apply guardrail to reasoning content
                                 try:
                                     validated_reasoning = self._apply_guardrail_with_retry(response.choices[0].message.reasoning_content, original_prompt, temperature, tools)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_reasoning, time.time() - start_time)
                                     return validated_reasoning
                                 except Exception as e:
                                     logging.error(f"Agent {self.name}: Guardrail validation failed for reasoning content: {e}")
@@ -1349,6 +1403,8 @@ Your Goal: {self.goal}"""
                             # Apply guardrail to regular response
                             try:
                                 validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                # Execute callback after validation
+                                self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
                                 return validated_response
                             except Exception as e:
                                 logging.error(f"Agent {self.name}: Guardrail validation failed: {e}")
@@ -1412,12 +1468,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
                                 # User message already added before LLM call via _build_messages
                                 self.chat_history.append({"role": "assistant", "content": response_text})
-                                # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                                if self.verbose and not self._using_custom_llm:
-                                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                                 # Apply guardrail validation after satisfactory reflection
                                 try:
                                     validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
                                     return validated_response
                                 except Exception as e:
                                     logging.error(f"Agent {self.name}: Guardrail validation failed after reflection: {e}")
@@ -1431,12 +1486,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     display_self_reflection("Maximum reflection count reached, returning current response", console=self.console)
                                 # User message already added before LLM call via _build_messages
                                 self.chat_history.append({"role": "assistant", "content": response_text})
-                                # Only display interaction if not using custom LLM (to avoid double output) and verbose is True
-                                if self.verbose and not self._using_custom_llm:
-                                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                                 # Apply guardrail validation after max reflections
                                 try:
                                     validated_response = self._apply_guardrail_with_retry(response_text, original_prompt, temperature, tools)
+                                    # Execute callback after validation
+                                    self._execute_callback_and_display(original_prompt, validated_response, time.time() - start_time)
                                     return validated_response
                                 except Exception as e:
                                     logging.error(f"Agent {self.name}: Guardrail validation failed after max reflections: {e}")
@@ -1551,6 +1605,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         agent_name=self.name,
                         agent_role=self.role,
                         agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)],
+                        task_name=task_name,
+                        task_description=task_description,
+                        task_id=task_id,
                         execute_tool_fn=self.execute_tool_async,
                         reasoning_steps=reasoning_steps
                     )
@@ -1869,6 +1926,26 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         """Start the agent with a prompt. This is a convenience method that wraps chat()."""
         return self.chat(prompt, **kwargs) 
 
+    def execute(self, task, context=None):
+        """Execute a task synchronously - backward compatibility method"""
+        if hasattr(task, 'description'):
+            prompt = task.description
+        elif isinstance(task, str):
+            prompt = task
+        else:
+            prompt = str(task)
+        return self.chat(prompt)
+
+    async def aexecute(self, task, context=None):
+        """Execute a task asynchronously - backward compatibility method"""
+        if hasattr(task, 'description'):
+            prompt = task.description
+        elif isinstance(task, str):
+            prompt = task
+        else:
+            prompt = str(task)
+        return await self.achat(prompt)
+
     async def execute_tool_async(self, function_name: str, arguments: Dict[str, Any]) -> Any:
         """Async version of execute_tool"""
         try:

{praisonaiagents-0.0.130 → praisonaiagents-0.0.132}/praisonaiagents/agent/image_agent.py

@@ -144,8 +144,17 @@ class ImageAgent(Agent):
         config = self.image_config.dict(exclude_none=True)
         config.update(kwargs)
         
-        # Use llm parameter as the model
-        config['model'] = self.llm
+        # Get the model name robustly from the parent Agent's property
+        model_info = self.llm_model
+        model_name = model_info.model if hasattr(model_info, 'model') else str(model_info)
+        
+        # Use the model name in config
+        config['model'] = model_name
+
+        # Check if we're using a Gemini model and remove unsupported parameters
+        if 'gemini' in model_name.lower():
+            # Gemini models don't support response_format parameter
+            config.pop('response_format', None)
 
         with Progress(
             SpinnerColumn(),
@@ -154,7 +163,7 @@ class ImageAgent(Agent):
         ) as progress:
             try:
                 # Add a task for image generation
-                task = progress.add_task(f"[cyan]Generating image with {self.llm}...", total=None)
+                task = progress.add_task(f"[cyan]Generating image with {model_name}...", total=None)
                 
                 # Use litellm's image generation
                 response = self.litellm(

{praisonaiagents-0.0.130 → praisonaiagents-0.0.132}/praisonaiagents/agents/agents.py

@@ -491,18 +491,35 @@ Context:
                         tasks_to_run = []
                     
                     # Run sync task in an executor to avoid blocking the event loop
-                    loop = asyncio.get_event_loop()
+                    loop = asyncio.get_running_loop()
                     await loop.run_in_executor(None, self.run_task, task_id)
 
             if tasks_to_run:
                 await asyncio.gather(*tasks_to_run)
                 
         elif self.process == "sequential":
+            async_tasks_to_run = []
+            
+            async def flush_async_tasks():
+                """Execute all pending async tasks"""
+                nonlocal async_tasks_to_run
+                if async_tasks_to_run:
+                    await asyncio.gather(*async_tasks_to_run)
+                    async_tasks_to_run = []
+            
             async for task_id in process.asequential():
                 if self.tasks[task_id].async_execution:
-                    await self.arun_task(task_id)
+                    # Collect async tasks to run in parallel
+                    async_tasks_to_run.append(self.arun_task(task_id))
                 else:
-                    self.run_task(task_id)
+                    # Before running a sync task, execute all pending async tasks
+                    await flush_async_tasks()
+                    # Run sync task in an executor to avoid blocking the event loop
+                    loop = asyncio.get_running_loop()
+                    await loop.run_in_executor(None, self.run_task, task_id)
+            
+            # Execute any remaining async tasks at the end
+            await flush_async_tasks()
         elif self.process == "hierarchical":
             async for task_id in process.ahierarchical():
                 if isinstance(task_id, Task):
@@ -510,7 +527,9 @@ Context:
                 if self.tasks[task_id].async_execution:
                     await self.arun_task(task_id)
                 else:
-                    self.run_task(task_id)
+                    # Run sync task in an executor to avoid blocking the event loop
+                    loop = asyncio.get_running_loop()
+                    await loop.run_in_executor(None, self.run_task, task_id)
 
     async def astart(self, content=None, return_dict=False, **kwargs):
         """Async version of start method
@@ -670,7 +689,10 @@ Context:
                 _get_multimodal_message(task_prompt, task.images),
                 tools=task.tools,
                 output_json=task.output_json,
-                output_pydantic=task.output_pydantic
+                output_pydantic=task.output_pydantic,
+                task_name=task.name,
+                task_description=task.description,
+                task_id=task_id
             )
         else:
             agent_output = executor_agent.chat(
@@ -679,6 +701,9 @@ Context:
                 output_json=task.output_json,
                 output_pydantic=task.output_pydantic,
                 stream=self.stream,
+                task_name=task.name,
+                task_description=task.description,
+                task_id=task_id
             )
 
         if agent_output:
@@ -1116,7 +1141,7 @@ Context:
                                 response = await agent_instance.achat(current_input)
                             else:
                                 # Run sync function in a thread to avoid blocking
-                                loop = asyncio.get_event_loop()
+                                loop = asyncio.get_running_loop()
                                 # Correctly pass current_input to the lambda for closure
                                 response = await loop.run_in_executor(None, lambda ci=current_input: agent_instance.chat(ci))
                             
@@ -1271,7 +1296,7 @@ Context:
                         if hasattr(agent_instance, 'achat') and asyncio.iscoroutinefunction(agent_instance.achat):
                             response = await agent_instance.achat(current_input, tools=agent_instance.tools)
                         elif hasattr(agent_instance, 'chat'): # Fallback to sync chat if achat not suitable
-                            loop = asyncio.get_event_loop()
+                            loop = asyncio.get_running_loop()
                             response = await loop.run_in_executor(None, lambda ci=current_input: agent_instance.chat(ci, tools=agent_instance.tools))
                         else:
                             logging.warning(f"Agent {agent_instance.name} has no suitable chat or achat method.")

{praisonaiagents-0.0.130 → praisonaiagents-0.0.132}/praisonaiagents/guardrails/llm_guardrail.py

@@ -19,12 +19,54 @@ class LLMGuardrail:
         
         Args:
             description: Natural language description of what to validate
-            llm: The LLM instance to use for validation
+            llm: The LLM instance to use for validation (can be string or LLM instance)
         """
         self.description = description
-        self.llm = llm
+        self.llm = self._initialize_llm(llm)
         self.logger = logging.getLogger(__name__)
     
+    def _initialize_llm(self, llm: Any) -> Any:
+        """Initialize the LLM instance from string identifier or existing instance.
+        
+        Args:
+            llm: String identifier, LLM instance, or None
+            
+        Returns:
+            LLM instance or None
+        """
+        # Local import to avoid circular dependencies
+        def _get_llm_class():
+            from ..llm.llm import LLM
+            return LLM
+            
+        if llm is None:
+            return None
+            
+        # If it's already an LLM instance, return as-is
+        if hasattr(llm, 'chat') or hasattr(llm, 'get_response') or callable(llm):
+            return llm
+            
+        # If it's a string, convert to LLM instance
+        if isinstance(llm, str):
+            try:
+                # Handle string identifiers (both provider/model and simple names)
+                return _get_llm_class()(model=llm)
+            except Exception as e:
+                self.logger.error(f"Failed to initialize LLM from string '{llm}': {str(e)}")
+                return None
+        
+        # If it's a dict, pass parameters to LLM
+        if isinstance(llm, dict) and "model" in llm:
+            try:
+                return _get_llm_class()(**llm)
+            except Exception as e:
+                self.logger.error(f"Failed to initialize LLM from dict: {str(e)}")
+                return None
+        
+        # Unknown type
+        self.logger.warning(f"Unknown LLM type: {type(llm)}, treating as-is")
+        return llm
+    
     def __call__(self, task_output: TaskOutput) -> Tuple[bool, Union[str, TaskOutput]]:
         """Validate the task output using the LLM.