fix: resolve critical runtime issues in callback enhancement

- Fix undefined variables in llm.py response() and aresponse() methods
  by adding missing parameters to method signatures
- Fix backward compatibility by adding signature checking to callbacks
  in display_interaction(), execute_callback(), and execute_sync_callback()
- Ensure consistent parameter propagation in agent.py get_response calls
- Legacy callbacks now work without TypeError, new callbacks get full context

Co-authored-by: Mervin Praison <MervinPraison@users.noreply.github.com>

Author: github-actions[bot]

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

@@ -1100,6 +1100,10 @@ def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, r
                         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:
@@ -1116,6 +1120,10 @@ def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, r
                         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:
@@ -1162,12 +1170,24 @@ def _execute_callback_and_display(self, prompt: str, response: str, generation_t
                 message=prompt,
                 response=response,
                 markdown=self.markdown,
-                generation_time=generation_time
+                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)
+                              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
@@ -1585,6 +1605,9 @@ async def achat(self, prompt: str, temperature=0.2, tools=None, output_json=None
                         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
                     )

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

@@ -2153,6 +2153,12 @@ def response(
         verbose: bool = True,
         markdown: bool = True,
         console: Optional[Console] = None,
+        agent_name: Optional[str] = None,
+        agent_role: Optional[str] = None,
+        agent_tools: Optional[List[str]] = None,
+        task_name: Optional[str] = None,
+        task_description: Optional[str] = None,
+        task_id: Optional[str] = None,
         **kwargs
     ) -> str:
         """Simple function to get model response without tool calls or complex features"""
@@ -2246,6 +2252,12 @@ async def aresponse(
         verbose: bool = True,
         markdown: bool = True,
         console: Optional[Console] = None,
+        agent_name: Optional[str] = None,
+        agent_role: Optional[str] = None,
+        agent_tools: Optional[List[str]] = None,
+        task_name: Optional[str] = None,
+        task_description: Optional[str] = None,
+        task_id: Optional[str] = None,
         **kwargs
     ) -> str:
         """Async version of response function"""

src/praisonai-agents/praisonaiagents/main.py

@@ -73,7 +73,18 @@ def execute_sync_callback(display_type: str, **kwargs):
     """
     if display_type in sync_display_callbacks:
         callback = sync_display_callbacks[display_type]
-        callback(**kwargs)
+        import inspect
+        sig = inspect.signature(callback)
+        
+        # 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 = kwargs
+        else:
+            # Only pass arguments that the callback signature supports
+            supported_kwargs = {k: v for k, v in kwargs.items() if k in sig.parameters}
+        
+        callback(**supported_kwargs)
 
 async def execute_callback(display_type: str, **kwargs):
     """Execute both sync and async callbacks for a given display type.
@@ -82,16 +93,38 @@ async def execute_callback(display_type: str, **kwargs):
         display_type (str): Type of display event
         **kwargs: Arguments to pass to the callback functions
     """
+    import inspect
+    
     # Execute synchronous callback if registered
     if display_type in sync_display_callbacks:
         callback = sync_display_callbacks[display_type]
+        sig = inspect.signature(callback)
+        
+        # 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 = kwargs
+        else:
+            # Only pass arguments that the callback signature supports
+            supported_kwargs = {k: v for k, v in kwargs.items() if k in sig.parameters}
+        
         loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, lambda: callback(**kwargs))
+        await loop.run_in_executor(None, lambda: callback(**supported_kwargs))
 
     # Execute asynchronous callback if registered
     if display_type in async_display_callbacks:
         callback = async_display_callbacks[display_type]
-        await callback(**kwargs)
+        sig = inspect.signature(callback)
+        
+        # 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 = kwargs
+        else:
+            # Only pass arguments that the callback signature supports
+            supported_kwargs = {k: v for k, v in kwargs.items() if k in sig.parameters}
+        
+        await callback(**supported_kwargs)
 
 def _clean_display_content(content: str, max_length: int = 20000) -> str:
     """Helper function to clean and truncate content for display."""
@@ -129,18 +162,32 @@ def display_interaction(message, response, markdown=True, generation_time=None,
 
     # Execute synchronous callback if registered
     if 'interaction' in sync_display_callbacks:
-        sync_display_callbacks['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
-        )
+        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)
     # Rest of the display logic...
     if generation_time:
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))