praisonaiagents 0.0.130__py3-none-any.whl → 0.0.131__py3-none-any.whl

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
                     )

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/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/llm/llm.py

@@ -14,6 +14,7 @@ from ..main import (
     display_generating,
     display_self_reflection,
     ReflectionOutput,
+    execute_sync_callback,
 )
 from rich.console import Console
 from rich.live import Live
@@ -130,8 +131,10 @@ class LLM:
             if 'tools' in safe_config:
                 tools = safe_config['tools']
                 # Check if tools is iterable before processing
-                if tools and hasattr(tools, '__iter__') and not isinstance(tools, str):
+                if tools and isinstance(tools, (list, tuple)):
                     safe_config['tools'] = [t.__name__ if hasattr(t, "__name__") else str(t) for t in tools]
+                elif tools and callable(tools):
+                    safe_config['tools'] = tools.__name__ if hasattr(tools, "__name__") else str(tools)
                 else:
                     safe_config['tools'] = None
             if 'output_json' in safe_config:
@@ -617,6 +620,9 @@ class LLM:
         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,
         execute_tool_fn: Optional[Callable] = None,
         stream: bool = True,
         **kwargs
@@ -692,6 +698,7 @@ class LLM:
 
             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
 
             # Display initial instruction once
@@ -737,6 +744,19 @@ class LLM:
                         response_text = resp["choices"][0]["message"]["content"]
                         final_response = resp
                         
+                        # Always execute callbacks regardless of 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:
                             display_interaction(
@@ -744,7 +764,13 @@ class LLM:
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
                                 generation_time=time.time() - current_time,
-                                console=console
+                                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
                         elif verbose and not interaction_displayed:
@@ -753,7 +779,13 @@ class LLM:
                                 response_text,
                                 markdown=markdown,
                                 generation_time=time.time() - current_time,
-                                console=console
+                                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
                     
@@ -815,6 +847,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
+                            )
+
+                            
                             # Create a mock final_response with the captured data
                             final_response = {
                                 "choices": [{
@@ -839,6 +881,16 @@ 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
+                            )
+                            
+
                             if verbose and not interaction_displayed:
                                 # Display the complete response at once
                                 display_interaction(
@@ -846,7 +898,13 @@ class LLM:
                                     response_text,
                                     markdown=markdown,
                                     generation_time=time.time() - current_time,
-                                    console=console
+                                    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
                     
@@ -926,16 +984,14 @@ class LLM:
                             iteration_count += 1
                             continue
 
-                        # For Ollama, add explicit prompt if we need a final answer
-                        if self._is_ollama_provider() and iteration_count > 0:
-                            # Add an explicit prompt for Ollama to generate the final answer
-                            messages.append({
-                                "role": "user", 
-                                "content": self.OLLAMA_FINAL_ANSWER_PROMPT
-                            })
+                        # Check if the LLM provided a final answer alongside the tool calls
+                        # If response_text contains substantive content, treat it as the final answer
+                        if response_text and response_text.strip() and len(response_text.strip()) > 10:
+                            # LLM provided a final answer after tool execution, don't continue
+                            final_response_text = response_text.strip()
+                            break
                         
-                        # After tool execution, continue the loop to check if more tools are needed
-                        # instead of immediately trying to get a final response
+                        # Otherwise, continue the loop to check if more tools are needed
                         iteration_count += 1
                         continue
                     else:
@@ -954,6 +1010,17 @@ 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
                 if stored_reasoning_content:
@@ -962,7 +1029,13 @@ class LLM:
                         f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}",
                         markdown=markdown,
                         generation_time=time.time() - start_time,
-                        console=console
+                        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
                     )
                 else:
                     display_interaction(
@@ -970,7 +1043,13 @@ class LLM:
                         response_text,
                         markdown=markdown,
                         generation_time=time.time() - start_time,
-                        console=console
+                        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
             
@@ -984,16 +1063,39 @@ 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)
+                                     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:
+                    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)
+                                     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 reasoning content if reasoning_steps is True
                 if reasoning_steps and stored_reasoning_content:
@@ -1039,7 +1141,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console
+                            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
                         )
                     elif verbose:
                         display_interaction(
@@ -1047,7 +1155,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             reflection_text,
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console
+                            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
                         )
                 else:
                     # Existing streaming approach
@@ -1098,14 +1212,18 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if satisfactory and reflection_count >= min_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
+                                             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 reflection_count >= max_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
+                                             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
 
@@ -1126,6 +1244,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                     messages=messages,
                                     temperature=temperature,
                                     stream=True,
+                                    tools=formatted_tools,
                                     output_json=output_json,
                                     output_pydantic=output_pydantic,
                                     **kwargs
@@ -1142,6 +1261,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 messages=messages,
                                 temperature=temperature,
                                 stream=True,
+                                tools=formatted_tools,
                                 output_json=output_json,
                                 output_pydantic=output_pydantic,
                                 **kwargs
@@ -1158,7 +1278,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if reflection_count >= max_reflect:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
+                                             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
                     continue
@@ -1206,6 +1328,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         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,
         execute_tool_fn: Optional[Callable] = None,
         stream: bool = True,
         **kwargs
@@ -1313,7 +1438,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console
+                            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
                     elif verbose and not interaction_displayed:
@@ -1322,7 +1453,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             response_text,
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console
+                            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
                 else:
@@ -1406,7 +1543,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 response_text,
                                 markdown=markdown,
                                 generation_time=time.time() - start_time,
-                                console=console
+                                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
 
@@ -1500,7 +1643,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
                                 markdown=markdown,
                                 generation_time=time.time() - start_time,
-                                console=console
+                                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
                         elif verbose and not interaction_displayed:
@@ -1509,7 +1658,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 response_text,
                                 markdown=markdown,
                                 generation_time=time.time() - start_time,
-                                console=console
+                                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
                     else:
@@ -1559,6 +1714,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if reasoning_steps and reasoning_content:
                         stored_reasoning_content = reasoning_content
                     
+                    # Check if the LLM provided a final answer alongside the tool calls
+                    # If response_text contains substantive content, treat it as the final answer
+                    if response_text and response_text.strip() and len(response_text.strip()) > 10:
+                        # LLM provided a final answer after tool execution, don't continue
+                        final_response_text = response_text.strip()
+                        break
+                    
                     # Continue the loop to check if more tools are needed
                     iteration_count += 1
                     continue
@@ -1575,7 +1737,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 self.chat_history.append({"role": "assistant", "content": response_text})
                 if verbose and not interaction_displayed:
                     display_interaction(original_prompt, response_text, markdown=markdown,
-                                     generation_time=time.time() - start_time, console=console)
+                                     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
 
@@ -1591,11 +1755,19 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{display_text}",
                             markdown=markdown,
                             generation_time=time.time() - start_time,
-                            console=console
+                            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
                         )
                     else:
                         display_interaction(original_prompt, display_text, markdown=markdown,
-                                         generation_time=time.time() - start_time, console=console)
+                                         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 reasoning content if reasoning_steps is True and we have it
@@ -1640,7 +1812,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         f"{reasoning_content}\n\nReflection result:\n{reflection_text}",
                         markdown=markdown,
                         generation_time=time.time() - start_time,
-                        console=console
+                        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
                     )
                 elif verbose:
                     display_interaction(
@@ -1648,7 +1826,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                         reflection_text,
                         markdown=markdown,
                         generation_time=time.time() - start_time,
-                        console=console
+                        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
                     )
             else:
                 # Existing streaming approach
@@ -1700,14 +1884,18 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     if satisfactory and reflection_count >= min_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
+                                             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 reflection_count >= max_reflect - 1:
                         if verbose and not interaction_displayed:
                             display_interaction(prompt, response_text, markdown=markdown,
-                                             generation_time=time.time() - start_time, console=console)
+                                             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
 
@@ -1972,6 +2160,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         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"""
@@ -2040,7 +2234,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     response_text,
                     markdown=markdown,
                     generation_time=time.time() - start_time,
-                    console=console or self.console
+                    console=console or self.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
                 )
             
             return response_text.strip() if response_text else ""
@@ -2059,6 +2259,12 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         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"""
@@ -2128,7 +2334,13 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     response_text,
                     markdown=markdown,
                     generation_time=time.time() - start_time,
-                    console=console or self.console
+                    console=console or self.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
                 )
             
             return response_text.strip() if response_text else ""

praisonaiagents/main.py

@@ -62,6 +62,30 @@ def register_approval_callback(callback_fn):
     global approval_callback
     approval_callback = callback_fn
 
+def execute_sync_callback(display_type: str, **kwargs):
+    """Execute synchronous callback for a given display type without displaying anything.
+    
+    This function is used to trigger callbacks even when verbose=False.
+    
+    Args:
+        display_type (str): Type of display event
+        **kwargs: Arguments to pass to the callback function
+    """
+    if display_type in sync_display_callbacks:
+        callback = sync_display_callbacks[display_type]
+        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.
     
@@ -69,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."""
@@ -101,7 +147,7 @@ def _clean_display_content(content: str, max_length: int = 20000) -> str:
     
     return content.strip()
 
-def display_interaction(message, response, markdown=True, generation_time=None, console=None):
+def display_interaction(message, response, markdown=True, generation_time=None, console=None, agent_name=None, agent_role=None, agent_tools=None, task_name=None, task_description=None, task_id=None):
     """Synchronous version of display_interaction."""
     if console is None:
         console = Console()
@@ -113,15 +159,35 @@ 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:
-        sync_display_callbacks['interaction'](
-            message=message,
-            response=response,
-            markdown=markdown,
-            generation_time=generation_time
-        )
-
+        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"))
@@ -140,10 +206,6 @@ def display_self_reflection(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    # Execute callback if registered
-    if 'self_reflection' in sync_display_callbacks:
-        sync_display_callbacks['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):
@@ -153,10 +215,6 @@ def display_instruction(message: str, console=None, agent_name: str = None, agen
         console = Console()
     message = _clean_display_content(str(message))
     
-    # Execute callback if registered
-    if 'instruction' in sync_display_callbacks:
-        sync_display_callbacks['instruction'](message=message)
-    
     # Display agent info if available
     if agent_name:
         agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
@@ -181,10 +239,6 @@ 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 callback if registered
-    if 'tool_call' in sync_display_callbacks:
-        sync_display_callbacks['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):
@@ -194,10 +248,6 @@ def display_error(message: str, console=None):
         console = Console()
     message = _clean_display_content(str(message))
     
-    # Execute callback if registered
-    if 'error' in sync_display_callbacks:
-        sync_display_callbacks['error'](message=message)
-    
     console.print(Panel.fit(Text(message, style="bold red"), title="Error", border_style="red"))
     error_logs.append(message)
 
@@ -213,17 +263,10 @@ def display_generating(content: str = "", start_time: Optional[float] = None):
     
     content = _clean_display_content(str(content))
     
-    # Execute callback if registered
-    if 'generating' in sync_display_callbacks:
-        sync_display_callbacks['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
-async def adisplay_interaction(message, response, markdown=True, generation_time=None, console=None):
+async def adisplay_interaction(message, response, markdown=True, generation_time=None, console=None, agent_name=None, agent_role=None, agent_tools=None, task_name=None, task_description=None, task_id=None):
     """Async version of display_interaction."""
     if console is None:
         console = Console()
@@ -241,7 +284,13 @@ async def adisplay_interaction(message, response, markdown=True, generation_time
         message=message,
         response=response,
         markdown=markdown,
-        generation_time=generation_time
+        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...

praisonaiagents/memory/memory.py

@@ -116,6 +116,16 @@ class Memory:
         self.use_mem0 = (self.provider.lower() == "mem0") and MEM0_AVAILABLE
         self.use_rag = (self.provider.lower() == "rag") and CHROMADB_AVAILABLE and self.cfg.get("use_embedding", False)
         self.graph_enabled = False  # Initialize graph support flag
+        
+        # Extract embedding model from config
+        self.embedder_config = self.cfg.get("embedder", {})
+        if isinstance(self.embedder_config, dict):
+            embedder_model_config = self.embedder_config.get("config", {})
+            self.embedding_model = embedder_model_config.get("model", "text-embedding-3-small")
+        else:
+            self.embedding_model = "text-embedding-3-small"
+        
+        self._log_verbose(f"Using embedding model: {self.embedding_model}")
 
         # Create .praison directory if it doesn't exist
         os.makedirs(".praison", exist_ok=True)
@@ -355,7 +365,7 @@ class Memory:
                     import litellm
                     
                     response = litellm.embedding(
-                        model="text-embedding-3-small",
+                        model=self.embedding_model,
                         input=query
                     )
                     query_embedding = response.data[0]["embedding"]
@@ -366,7 +376,7 @@ class Memory:
                     
                     response = client.embeddings.create(
                         input=query,
-                        model="text-embedding-3-small"
+                        model=self.embedding_model
                     )
                     query_embedding = response.data[0].embedding
                 else:
@@ -496,7 +506,7 @@ class Memory:
                     logger.debug(f"Embedding input text: {text}")
                     
                     response = litellm.embedding(
-                        model="text-embedding-3-small",
+                        model=self.embedding_model,
                         input=text
                     )
                     embedding = response.data[0]["embedding"]
@@ -513,7 +523,7 @@ class Memory:
                     
                     response = client.embeddings.create(
                         input=text,
-                        model="text-embedding-3-small"
+                        model=self.embedding_model
                     )
                     embedding = response.data[0].embedding
                     logger.info("Successfully got embeddings from OpenAI")
@@ -576,7 +586,7 @@ class Memory:
                     import litellm
                     
                     response = litellm.embedding(
-                        model="text-embedding-3-small",
+                        model=self.embedding_model,
                         input=query
                     )
                     query_embedding = response.data[0]["embedding"]
@@ -587,7 +597,7 @@ class Memory:
                     
                     response = client.embeddings.create(
                         input=query,
-                        model="text-embedding-3-small"
+                        model=self.embedding_model
                     )
                     query_embedding = response.data[0].embedding
                 else:

{praisonaiagents-0.0.130.dist-info → praisonaiagents-0.0.131.dist-info}/METADATA

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

{praisonaiagents-0.0.130.dist-info → praisonaiagents-0.0.131.dist-info}/RECORD

@@ -1,14 +1,14 @@
 praisonaiagents/__init__.py,sha256=7DZJjhHa1_OeP0aiR5_iXINXYiug_gtbOuh_ylad6Uc,3847
 praisonaiagents/approval.py,sha256=UJ4OhfihpFGR5CAaMphqpSvqdZCHi5w2MGw1MByZ1FQ,9813
-praisonaiagents/main.py,sha256=7HEFVNmxMzRjVpbe52aYvQMZA013mA3YosrixM_Ua8Q,14975
+praisonaiagents/main.py,sha256=8iUDHu-BHM4DCEQlVfGQWhXbNB99DZxjV32sYlptbf8,17498
 praisonaiagents/session.py,sha256=d-CZPYikOHb0q-H9f_IWKJsypnQfz1YKeLLkyxs6oDo,15532
 praisonaiagents/agent/__init__.py,sha256=FkjW6f3EU8heQ9tvctfLbOWV9_dOXmS1PcFNgcStns8,403
-praisonaiagents/agent/agent.py,sha256=zuwZ3U-wwEu3x_BK4SYPJPKC7cZ_e8iak5ILn_H9yQE,119660
+praisonaiagents/agent/agent.py,sha256=uNpJ8ejF28-FJsFWLbk4SHFCjAlWT-gKav7zZz-gQ6k,122647
 praisonaiagents/agent/handoff.py,sha256=Saq0chqfvC6Zf5UbXvmctybbehqnotrXn72JsS-76Q0,13099
-praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
+praisonaiagents/agent/image_agent.py,sha256=Bbwg_h3qhjhG7gMH8sdcQXhcOFgE_wSvcdhtqH5f2UM,9145
 praisonaiagents/agent/router_agent.py,sha256=a_b6w5Ti05gvK80uKGMIcT14fiCTKv8rCQPCWAUfIiE,12713
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=21JwDl6-YBbZfEfWXgSJ-iqJ48kpAuG3OuzzwCHddEs,63161
+praisonaiagents/agents/agents.py,sha256=WfzlnwiqiEdU6z-6j_Xp0LyhIApKNj0G6L0Hlr418yE,64420
 praisonaiagents/agents/autoagents.py,sha256=v5pJfTgHnFzG5K2gHwfRA0nZ7Ikptir6hUNvOZ--E44,20777
 praisonaiagents/guardrails/__init__.py,sha256=HA8zhp-KRHTxo0194MUwXOUJjPyjOu7E3d7xUIKYVVY,310
 praisonaiagents/guardrails/guardrail_result.py,sha256=2K1WIYRyT_s1H6vBGa-7HEHzXCFIyZXZVY4f0hnQyWc,1352
@@ -17,7 +17,7 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=-di_h9HxXQfAhTMMerhK16tfw8DtUndp44TGkBOzkZs,15539
 praisonaiagents/llm/__init__.py,sha256=tHvWq5mv4K4MhWr0s6rqox8UnJ5RK0kXhYuD40WkZQA,1747
-praisonaiagents/llm/llm.py,sha256=pseLC7JKUz56QOuBtsZttbMAq0UrgCLHgxoeoNXoqrg,109070
+praisonaiagents/llm/llm.py,sha256=PFFrIUPKJ1fcb1N_vJkjLTj4IAILB1S6USmorxSr4cU,121087
 praisonaiagents/llm/model_capabilities.py,sha256=MrEDLpYk9U_xzvXXIKYD4-bnNQg_W4bnaoTPyBUHfcs,3231
 praisonaiagents/llm/model_router.py,sha256=Jy2pShlkLxqXF3quz-MRB3-6L9vaUSgUrf2YJs_Tsg0,13995
 praisonaiagents/llm/openai_client.py,sha256=6KANw9SNiglvfJvTcpDPZjuTKG6cThD1t-ZqgKvmZiw,45356
@@ -26,7 +26,7 @@ praisonaiagents/mcp/mcp.py,sha256=T0G0rQotHxk9qTnG1tjQLr4c0BUSLnEqz9sIMx4F954,21
 praisonaiagents/mcp/mcp_http_stream.py,sha256=Yh-69eIlLQS_M0bd__y7NzSjOqqX6R8Ed4eJQw6xXgg,18314
 praisonaiagents/mcp/mcp_sse.py,sha256=KO10tAgZ5vSKeRhkJIZcdJ0ZmhRybS39i1KybWt4D7M,9128
 praisonaiagents/memory/__init__.py,sha256=aEFdhgtTqDdMhc_JCWM-f4XI9cZIj7Wz5g_MUa-0amg,397
-praisonaiagents/memory/memory.py,sha256=D5BmQTktv6VOJ49yW2m1MjjCJ5UDSX1Qo46_443ymKo,44276
+praisonaiagents/memory/memory.py,sha256=hbqPQj6gvTq3pIO9Ww75xWSZJbVwjTPGvLZX0vZBIrI,44748
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=uYvxL1TD_2Ku04dyBN_GV3DvoCuyv3Y2Iy7QODNin18,73906
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
@@ -57,7 +57,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.130.dist-info/METADATA,sha256=yId1o9u0MH_G-DszUmZ31Hvn-PNznFt5l7bXCHeYh9U,1699
-praisonaiagents-0.0.130.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.130.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.130.dist-info/RECORD,,
+praisonaiagents-0.0.131.dist-info/METADATA,sha256=VXwZ3uzd7-OwCm2A1_ZKoU1OG-37s40N6qFW8RCmyqM,1699
+praisonaiagents-0.0.131.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.131.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.131.dist-info/RECORD,,