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

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,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:
-        sync_display_callbacks['interaction'](
-            message=message,
-            response=response,
-            markdown=markdown,
-            generation_time=generation_time
-        )
-
+    # 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"))
@@ -140,9 +191,8 @@ 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)
+    # 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"))
 
@@ -153,9 +203,8 @@ 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)
+    # 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:
@@ -181,9 +230,8 @@ 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)
+    # 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"))
 
@@ -194,9 +242,8 @@ 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)
+    # 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)
@@ -213,17 +260,13 @@ 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
-        )
+    # 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
-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...
@@ -263,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"))
 
@@ -276,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:
@@ -304,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"))
 
@@ -317,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)
@@ -336,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/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/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/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.130.dist-info → praisonaiagents-0.0.132.dist-info}/METADATA

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

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

@@ -1,23 +1,23 @@
 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=b5dKlkf6NMeumSzixreHB9ui90f8YMAi5r1fCbTpQVw,17225
 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=1m9s6irqenYatuoGHHS1DX913rm9QpjcJHJjvPH6_QE,123338
 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
-praisonaiagents/guardrails/llm_guardrail.py,sha256=MTTqmYDdZX-18QN9T17T5P_6H2qnV8GVgymJufW1WuM,3277
+praisonaiagents/guardrails/llm_guardrail.py,sha256=czdOIoY-3PZOchX317tz4O2h2WYE42Ua4tqVzyuoNlI,4859
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 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=UAoezf_FF435xNCpOq1TtuEngInIobgBGZiLSX2d8Wg,122381
 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,11 +26,11 @@ 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/process/process.py,sha256=wXKZ2Z26vB9osmVbD5xqkUlUQRvWEpvL8j9hiuiHrQ0,78246
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=ReLwXPpfu3L7ba97RpzCOp5eFbLj26oK9mDsnLX6Bok,21471
+praisonaiagents/task/task.py,sha256=-EXxw3czWZdAK1WWI6Dvga5CujsItgk9RWYD_CdW47w,24075
 praisonaiagents/telemetry/__init__.py,sha256=5iAOrj_N_cKMmh2ltWGYs3PfOYt_jcwUoElW8fTAIsc,3062
 praisonaiagents/telemetry/integration.py,sha256=8h8TDlPFTbsBmU5rIYNOibJbwEEEWmzS1ENE9uPTvvg,8696
 praisonaiagents/telemetry/telemetry.py,sha256=SAEK5lrHn-Rb3nk_Yx1sjAdRxqT63ycyNRv3ZGh9Rck,11812
@@ -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.132.dist-info/METADATA,sha256=J1a0z43TLhbIkkirbvjHsaM4eyhTOAFV1B08QXo4pmE,1699
+praisonaiagents-0.0.132.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.132.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.132.dist-info/RECORD,,