praisonaiagents 0.0.131__tar.gz → 0.0.132__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.131
+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.131 → praisonaiagents-0.0.132}/praisonaiagents/agent/agent.py

@@ -1926,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.131 → 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.
         

{praisonaiagents-0.0.131 → praisonaiagents-0.0.132}/praisonaiagents/llm/llm.py

@@ -744,18 +744,9 @@ class LLM:
                         response_text = resp["choices"][0]["message"]["content"]
                         final_response = resp
                         
-                        # Always execute callbacks regardless of verbose setting
+                        # Execute callbacks and display based on verbose setting
                         generation_time_val = time.time() - current_time
-                        interaction_displayed = False
-                        
                         response_content = f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}" if reasoning_content else response_text
-                        execute_sync_callback(
-                            'interaction',
-                            message=original_prompt,
-                            response=response_content,
-                            markdown=markdown,
-                            generation_time=generation_time_val
-                        )
                         
                         # Optionally display reasoning if present
                         if verbose and reasoning_content and not interaction_displayed:
@@ -763,7 +754,7 @@ class LLM:
                                 original_prompt,
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
-                                generation_time=time.time() - current_time,
+                                generation_time=generation_time_val,
                                 console=console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
@@ -773,12 +764,13 @@ class LLM:
                                 task_id=task_id
                             )
                             interaction_displayed = True
+                            callback_executed = True
                         elif verbose and not interaction_displayed:
                             display_interaction(
                                 original_prompt,
                                 response_text,
                                 markdown=markdown,
-                                generation_time=time.time() - current_time,
+                                generation_time=generation_time_val,
                                 console=console,
                                 agent_name=agent_name,
                                 agent_role=agent_role,
@@ -788,6 +780,17 @@ class LLM:
                                 task_id=task_id
                             )
                             interaction_displayed = True
+                            callback_executed = True
+                        elif not callback_executed:
+                            # Only execute callback if display_interaction hasn't been called (which would trigger callbacks internally)
+                            execute_sync_callback(
+                                'interaction',
+                                message=original_prompt,
+                                response=response_content,
+                                markdown=markdown,
+                                generation_time=generation_time_val
+                            )
+                            callback_executed = True
                     
                     # Otherwise do the existing streaming approach
                     else:
@@ -847,14 +850,16 @@ class LLM:
                             
                             response_text = response_text.strip() if response_text else ""
                             
-                            # Always execute callbacks after streaming completes
-                            execute_sync_callback(
-                                'interaction',
-                                message=original_prompt,
-                                response=response_text,
-                                markdown=markdown,
-                                generation_time=time.time() - current_time
-                            )
+                            # Execute callbacks after streaming completes (only if not verbose, since verbose will call display_interaction later)
+                            if not verbose and not callback_executed:
+                                execute_sync_callback(
+                                    'interaction',
+                                    message=original_prompt,
+                                    response=response_text,
+                                    markdown=markdown,
+                                    generation_time=time.time() - current_time
+                                )
+                                callback_executed = True
 
                             
                             # Create a mock final_response with the captured data
@@ -881,18 +886,9 @@ class LLM:
                             )
                             response_text = final_response["choices"][0]["message"]["content"]
                             
-                            # Always execute callbacks regardless of verbose setting
-                            execute_sync_callback(
-                                'interaction',
-                                message=original_prompt,
-                                response=response_text,
-                                markdown=markdown,
-                                generation_time=time.time() - current_time
-                            )
-                            
-
+                            # Execute callbacks and display based on verbose setting
                             if verbose and not interaction_displayed:
-                                # Display the complete response at once
+                                # Display the complete response at once (this will trigger callbacks internally)
                                 display_interaction(
                                     original_prompt,
                                     response_text,
@@ -907,6 +903,17 @@ class LLM:
                                     task_id=task_id
                                 )
                                 interaction_displayed = True
+                                callback_executed = True
+                            elif not callback_executed:
+                                # Only execute callback if display_interaction hasn't been called
+                                execute_sync_callback(
+                                    'interaction',
+                                    message=original_prompt,
+                                    response=response_text,
+                                    markdown=markdown,
+                                    generation_time=time.time() - current_time
+                                )
+                                callback_executed = True
                     
                     tool_calls = final_response["choices"][0]["message"].get("tool_calls")
                     
@@ -1010,16 +1017,8 @@ class LLM:
                 return final_response_text
             
             # No tool calls were made in this iteration, return the response
-            # Always execute callbacks regardless of verbose setting
             generation_time_val = time.time() - start_time
             response_content = f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}" if stored_reasoning_content else response_text
-            execute_sync_callback(
-                'interaction',
-                message=original_prompt,
-                response=response_content,
-                markdown=markdown,
-                generation_time=generation_time_val
-            )
             
             if verbose and not interaction_displayed:
                 # If we have stored reasoning content from tool execution, display it
@@ -1028,7 +1027,7 @@ class LLM:
                         original_prompt,
                         f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}",
                         markdown=markdown,
-                        generation_time=time.time() - start_time,
+                        generation_time=generation_time_val,
                         console=console,
                         agent_name=agent_name,
                         agent_role=agent_role,
@@ -1042,7 +1041,7 @@ class LLM:
                         original_prompt,
                         response_text,
                         markdown=markdown,
-                        generation_time=time.time() - start_time,
+                        generation_time=generation_time_val,
                         console=console,
                         agent_name=agent_name,
                         agent_role=agent_role,
@@ -1052,6 +1051,17 @@ class LLM:
                         task_id=task_id
                     )
                 interaction_displayed = True
+                callback_executed = True
+            elif not callback_executed:
+                # Only execute callback if display_interaction hasn't been called
+                execute_sync_callback(
+                    'interaction',
+                    message=original_prompt,
+                    response=response_content,
+                    markdown=markdown,
+                    generation_time=generation_time_val
+                )
+                callback_executed = True
             
             response_text = response_text.strip() if response_text else ""
             
@@ -1063,26 +1073,16 @@ class LLM:
             if output_json or output_pydantic:
                 self.chat_history.append({"role": "user", "content": original_prompt})
                 self.chat_history.append({"role": "assistant", "content": response_text})
-                # Always execute callbacks regardless of verbose setting
-                if not interaction_displayed:
-                    execute_sync_callback(
-                        'interaction',
-                        message=original_prompt,
-                        response=response_text,
-                        markdown=markdown,
-                        generation_time=time.time() - start_time
-                    )
+                
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
                                      generation_time=time.time() - start_time, console=console,
                                      agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                      task_name=task_name, task_description=task_description, task_id=task_id)
                     interaction_displayed = True
-                return response_text
-
-            if not self_reflect:
-                # Always execute callbacks regardless of verbose setting
-                if not interaction_displayed:
+                    callback_executed = True
+                elif not callback_executed:
+                    # Only execute callback if display_interaction hasn't been called
                     execute_sync_callback(
                         'interaction',
                         message=original_prompt,
@@ -1090,13 +1090,28 @@ class LLM:
                         markdown=markdown,
                         generation_time=time.time() - start_time
                     )
+                    callback_executed = True
+                return response_text
 
+            if not self_reflect:
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
                                      generation_time=time.time() - start_time, console=console,
                                      agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools,
                                      task_name=task_name, task_description=task_description, task_id=task_id)
                     interaction_displayed = True
+                    callback_executed = True
+                elif not callback_executed:
+                    # Only execute callback if display_interaction hasn't been called
+                    execute_sync_callback(
+                        'interaction',
+                        message=original_prompt,
+                        response=response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time
+                    )
+                    callback_executed = True
+                
                 # Return reasoning content if reasoning_steps is True
                 if reasoning_steps and stored_reasoning_content:
                     return stored_reasoning_content
@@ -1401,6 +1416,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
             start_time = time.time()
             reflection_count = 0
+            callback_executed = False  # Track if callback has been executed for this interaction
             interaction_displayed = False  # Track if interaction has been displayed
 
             # Format tools for LiteLLM using the shared helper
@@ -2031,10 +2047,11 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         output_json = override_params.get('output_json')
         output_pydantic = override_params.get('output_pydantic')
         
+        # Always remove these from params as they're not native litellm parameters
+        params.pop('output_json', None)
+        params.pop('output_pydantic', None)
+        
         if output_json or output_pydantic:
-            # Always remove these from params as they're not native litellm parameters
-            params.pop('output_json', None)
-            params.pop('output_pydantic', None)
             
             # Check if this is a Gemini model that supports native structured outputs
             if self._is_gemini_model():

{praisonaiagents-0.0.131 → praisonaiagents-0.0.132}/praisonaiagents/main.py

@@ -159,35 +159,20 @@ def display_interaction(message, response, markdown=True, generation_time=None,
     message = _clean_display_content(str(message))
     response = _clean_display_content(str(response))
 
-
-    # Execute synchronous callback if registered
-    if 'interaction' in sync_display_callbacks:
-        callback = sync_display_callbacks['interaction']
-        import inspect
-        sig = inspect.signature(callback)
-        
-        all_kwargs = {
-            'message': message,
-            'response': response,
-            'markdown': markdown,
-            'generation_time': generation_time,
-            'agent_name': agent_name,
-            'agent_role': agent_role,
-            'agent_tools': agent_tools,
-            'task_name': task_name,
-            'task_description': task_description,
-            'task_id': task_id
-        }
-        
-        # Filter kwargs to what the callback accepts to maintain backward compatibility
-        if any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()):
-            # Callback accepts **kwargs, so pass all arguments
-            supported_kwargs = all_kwargs
-        else:
-            # Only pass arguments that the callback signature supports
-            supported_kwargs = {k: v for k, v in all_kwargs.items() if k in sig.parameters}
-        
-        callback(**supported_kwargs)
+    # Execute synchronous callbacks
+    execute_sync_callback(
+        'interaction',
+        message=message,
+        response=response,
+        markdown=markdown,
+        generation_time=generation_time,
+        agent_name=agent_name,
+        agent_role=agent_role,
+        agent_tools=agent_tools,
+        task_name=task_name,
+        task_description=task_description,
+        task_id=task_id
+    )
     # Rest of the display logic...
     if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
@@ -206,6 +191,9 @@ def display_self_reflection(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
+    # Execute synchronous callbacks
+    execute_sync_callback('self_reflection', message=message)
+    
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
 def display_instruction(message: str, console=None, agent_name: str = None, agent_role: str = None, agent_tools: List[str] = None):
@@ -215,6 +203,9 @@ def display_instruction(message: str, console=None, agent_name: str = None, agen
         console = Console()
     message = _clean_display_content(str(message))
     
+    # Execute synchronous callbacks
+    execute_sync_callback('instruction', message=message, agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools)
+    
     # Display agent info if available
     if agent_name:
         agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
@@ -239,6 +230,9 @@ def display_tool_call(message: str, console=None):
     message = _clean_display_content(str(message))
     logging.debug(f"Cleaned message in display_tool_call: {repr(message)}")
     
+    # Execute synchronous callbacks
+    execute_sync_callback('tool_call', message=message)
+    
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
 def display_error(message: str, console=None):
@@ -248,6 +242,9 @@ def display_error(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
+    # Execute synchronous callbacks
+    execute_sync_callback('error', message=message)
+    
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
 
@@ -263,6 +260,9 @@ def display_generating(content: str = "", start_time: Optional[float] = None):
     
     content = _clean_display_content(str(content))
     
+    # Execute synchronous callbacks
+    execute_sync_callback('generating', content=content, elapsed_time=elapsed_str.strip() if elapsed_str else None)
+    
     return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
 
 # Async versions with 'a' prefix
@@ -312,8 +312,8 @@ async def adisplay_self_reflection(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'self_reflection' in async_display_callbacks:
-        await async_display_callbacks['self_reflection'](message=message)
+    # Execute callbacks
+    await execute_callback('self_reflection', message=message)
     
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
@@ -325,8 +325,8 @@ async def adisplay_instruction(message: str, console=None, agent_name: str = Non
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'instruction' in async_display_callbacks:
-        await async_display_callbacks['instruction'](message=message)
+    # Execute callbacks
+    await execute_callback('instruction', message=message, agent_name=agent_name, agent_role=agent_role, agent_tools=agent_tools)
     
     # Display agent info if available
     if agent_name:
@@ -353,8 +353,8 @@ async def adisplay_tool_call(message: str, console=None):
     message = _clean_display_content(str(message))
     logging.debug(f"Cleaned message in adisplay_tool_call: {repr(message)}")
     
-    if 'tool_call' in async_display_callbacks:
-        await async_display_callbacks['tool_call'](message=message)
+    # Execute callbacks
+    await execute_callback('tool_call', message=message)
     
     console.print(Panel.fit(Text(message, style="bold cyan"), title="Tool Call", border_style="green"))
 
@@ -366,8 +366,8 @@ async def adisplay_error(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    if 'error' in async_display_callbacks:
-        await async_display_callbacks['error'](message=message)
+    # Execute callbacks
+    await execute_callback('error', message=message)
     
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
@@ -385,11 +385,8 @@ async def adisplay_generating(content: str = "", start_time: Optional[float] = N
     
     content = _clean_display_content(str(content))
     
-    if 'generating' in async_display_callbacks:
-        await async_display_callbacks['generating'](
-            content=content,
-            elapsed_time=elapsed_str.strip() if elapsed_str else None
-        )
+    # Execute callbacks
+    await execute_callback('generating', content=content, elapsed_time=elapsed_str.strip() if elapsed_str else None)
     
     return Panel(Markdown(content), title=f"Generating...{elapsed_str}", border_style="green")
 

{praisonaiagents-0.0.131 → praisonaiagents-0.0.132}/praisonaiagents/process/process.py

@@ -59,10 +59,90 @@ class Process:
 
     def _create_loop_subtasks(self, loop_task: Task):
         """Create subtasks for a loop task from input file."""
-        logging.warning(f"_create_loop_subtasks called for {loop_task.name} but method not fully implemented")
-        # TODO: Implement loop subtask creation from input file
-        # This should read loop_task.input_file and create subtasks
-        pass
+        if not loop_task.input_file:
+            logging.warning(f"_create_loop_subtasks called for {loop_task.name} but no input_file specified")
+            return
+            
+        try:
+            file_ext = os.path.splitext(loop_task.input_file)[1].lower()
+            new_tasks = []
+
+            if file_ext == ".csv":
+                with open(loop_task.input_file, "r", encoding="utf-8") as f:
+                    reader = csv.reader(f, quotechar='"', escapechar='\\')
+                    previous_task = None
+                    task_count = 0
+
+                    for i, row in enumerate(reader):
+                        if not row:  # Skip empty rows
+                            continue
+
+                        # Handle Q&A pairs with potential commas
+                        task_desc = row[0].strip() if row else ""
+                        if len(row) > 1:
+                            question = row[0].strip()
+                            answer = ",".join(field.strip() for field in row[1:])
+                            task_desc = f"Question: {question}\nAnswer: {answer}"
+
+                        if not task_desc:  # Skip rows with empty content
+                            continue
+
+                        task_count += 1
+                        logging.debug(f"Creating subtask from CSV row {i+1}: {task_desc}")
+
+                        row_task = Task(
+                            description=f"{loop_task.description}\n{task_desc}" if loop_task.description else task_desc,
+                            agent=loop_task.agent,
+                            name=f"{loop_task.name}_{task_count}" if loop_task.name else task_desc,
+                            expected_output=getattr(loop_task, 'expected_output', None),
+                            callback=loop_task.callback,  # Inherit callback from parent loop task
+                            is_start=(task_count == 1),
+                            task_type="task"
+                        )
+                        self.tasks[row_task.id] = row_task
+                        new_tasks.append(row_task)
+
+                        if previous_task:
+                            previous_task.next_tasks = [row_task.name]
+                        previous_task = row_task
+
+                    logging.info(f"Created {task_count} subtasks from CSV file for {loop_task.name}")
+            else:
+                # Handle text files
+                with open(loop_task.input_file, "r", encoding="utf-8") as f:
+                    lines = f.read().splitlines()
+                    previous_task = None
+                    for i, line in enumerate(lines):
+                        if not line.strip():  # Skip empty lines
+                            continue
+                            
+                        row_task = Task(
+                            description=f"{loop_task.description}\n{line.strip()}" if loop_task.description else line.strip(),
+                            agent=loop_task.agent,
+                            name=f"{loop_task.name}_{i+1}" if loop_task.name else line.strip(),
+                            expected_output=getattr(loop_task, 'expected_output', None),
+                            callback=loop_task.callback,  # Inherit callback from parent loop task
+                            is_start=(i == 0),
+                            task_type="task"
+                        )
+                        self.tasks[row_task.id] = row_task
+                        new_tasks.append(row_task)
+
+                        if previous_task:
+                            previous_task.next_tasks = [row_task.name]
+                        previous_task = row_task
+
+                    logging.info(f"Created {len(new_tasks)} subtasks from text file for {loop_task.name}")
+
+            if new_tasks and loop_task.next_tasks:
+                # Connect last subtask to loop task's next tasks
+                last_task = new_tasks[-1]
+                last_task.next_tasks = loop_task.next_tasks
+
+        except Exception as e:
+            logging.error(f"Failed to create subtasks for loop task {loop_task.name}: {e}")
+            import traceback
+            traceback.print_exc()
 
     def _build_task_context(self, current_task: Task) -> str:
         """Build context for a task based on its retain_full_context setting"""
@@ -809,6 +889,7 @@ Provide a JSON with the structure:
                                 agent=start_task.agent,
                                 name=f"{start_task.name}_{task_count}" if start_task.name else task_desc,
                                 expected_output=getattr(start_task, 'expected_output', None),
+                                callback=start_task.callback,  # Inherit callback from parent loop task
                                 is_start=(task_count == 1),
                                 task_type="decision",  # Change to decision type
                                 next_tasks=inherited_next_tasks,  # Inherit parent's next tasks
@@ -842,6 +923,7 @@ Provide a JSON with the structure:
                                 agent=start_task.agent,
                                 name=f"{start_task.name}_{i+1}" if start_task.name else line.strip(),
                                 expected_output=getattr(start_task, 'expected_output', None),
+                                callback=start_task.callback,  # Inherit callback from parent loop task
                                 is_start=(i == 0),
                                 task_type="task",
                                 condition={
@@ -925,6 +1007,7 @@ Tasks by type:
                                             agent=current_task.agent,
                                             name=f"{current_task.name}_{i+1}" if current_task.name else task_desc,
                                             expected_output=getattr(current_task, 'expected_output', None),
+                                            callback=current_task.callback,  # Inherit callback from parent loop task
                                             is_start=(i == 0),
                                             task_type="task",
                                             condition={
@@ -949,6 +1032,7 @@ Tasks by type:
                                         agent=current_task.agent,
                                         name=f"{current_task.name}_{i+1}" if current_task.name else line.strip(),
                                         expected_output=getattr(current_task, 'expected_output', None),
+                                        callback=current_task.callback,  # Inherit callback from parent loop task
                                         is_start=(i == 0),
                                         task_type="task",
                                         condition={

{praisonaiagents-0.0.131 → praisonaiagents-0.0.132}/praisonaiagents/task/task.py

@@ -381,13 +381,10 @@ class Task:
                 logger.exception(e)  # Print full stack trace
                 # Continue execution even if memory operations fail
 
-        # Execute original callback
+        # Execute original callback with metadata support
         if self.callback:
             try:
-                if asyncio.iscoroutinefunction(self.callback):
-                    await self.callback(task_output)
-                else:
-                    self.callback(task_output)
+                await self._execute_callback_with_metadata(task_output)
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to execute callback: {e}")
                 logger.exception(e)
@@ -470,4 +467,63 @@ Context:
                 success=False,
                 result=None,
                 error=f"Guardrail validation error: {str(e)}"
-            )
+            )
+    
+    async def _execute_callback_with_metadata(self, task_output):
+        """Execute callback with metadata support while maintaining backward compatibility.
+        
+        This method automatically detects the callback signature:
+        - Single parameter callbacks receive only TaskOutput (backward compatible)
+        - Two parameter callbacks receive TaskOutput and metadata dict (enhanced)
+        
+        Args:
+            task_output: The TaskOutput object to pass to the callback
+        """
+        if not self.callback:
+            return
+            
+        try:
+            # Inspect the callback signature to determine parameter count
+            sig = inspect.signature(self.callback)
+            param_count = len(sig.parameters)
+            
+            if param_count == 1:
+                # Backward compatible: single parameter callback
+                if asyncio.iscoroutinefunction(self.callback):
+                    await self.callback(task_output)
+                else:
+                    self.callback(task_output)
+            elif param_count >= 2:
+                # Enhanced: two parameter callback with metadata
+                metadata = {
+                    'task_id': self.id,
+                    'task_name': self.name,
+                    'agent_name': self.agent.name if self.agent else None,
+                    'task_type': self.task_type,
+                    'task_status': self.status,
+                    'task_description': self.description,
+                    'expected_output': self.expected_output,
+                    'input_file': getattr(self, 'input_file', None),
+                    'loop_state': self.loop_state,
+                    'retry_count': getattr(self, 'retry_count', 0),
+                    'async_execution': self.async_execution
+                }
+                
+                if asyncio.iscoroutinefunction(self.callback):
+                    await self.callback(task_output, metadata)
+                else:
+                    self.callback(task_output, metadata)
+            else:
+                # No parameter callback - unusual but handle gracefully
+                if asyncio.iscoroutinefunction(self.callback):
+                    await self.callback()
+                else:
+                    self.callback()
+                    
+        except TypeError as e:
+            # Fallback for signature inspection issues
+            logger.warning(f"Task {self.id}: Callback signature inspection failed, falling back to single parameter: {e}")
+            if asyncio.iscoroutinefunction(self.callback):
+                await self.callback(task_output)
+            else:
+                self.callback(task_output)

{praisonaiagents-0.0.131 → praisonaiagents-0.0.132}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.131
+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.131 → praisonaiagents-0.0.132}/pyproject.toml

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