PraisonAI 4.6.53__tar.gz → 4.6.55__tar.gz

{praisonai-4.6.53 → praisonai-4.6.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.53
+Version: 4.6.55
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.53
+Requires-Dist: praisonaiagents>=1.6.55
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.53 → praisonai-4.6.55}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.53
+Version: 4.6.55
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.53
+Requires-Dist: praisonaiagents>=1.6.55
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.53 → praisonai-4.6.55}/PraisonAI.egg-info/SOURCES.txt

@@ -621,12 +621,14 @@ praisonai/persistence/factory.py
 praisonai/persistence/orchestrator.py
 praisonai/persistence/registry.py
 praisonai/persistence/conversation/__init__.py
+praisonai/persistence/conversation/_sql_base.py
 praisonai/persistence/conversation/async_mysql.py
 praisonai/persistence/conversation/async_postgres.py
 praisonai/persistence/conversation/async_sqlite.py
 praisonai/persistence/conversation/base.py
 praisonai/persistence/conversation/json_store.py
 praisonai/persistence/conversation/mysql.py
+praisonai/persistence/conversation/mysql_new.py
 praisonai/persistence/conversation/postgres.py
 praisonai/persistence/conversation/singlestore.py
 praisonai/persistence/conversation/sqlite.py

{praisonai-4.6.53 → praisonai-4.6.55}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.53
+praisonaiagents>=1.6.55
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.53 → praisonai-4.6.55}/praisonai/_registry.py

@@ -17,6 +17,8 @@ logger = logging.getLogger(__name__)
 
 
 class PluginRegistry(Generic[T]):
+    # Guards creation of per-subclass default-instance locks
+    _default_locks_guard = threading.Lock()
     """Generic plugin registry: builtins + entry points + runtime register().
     
     This replaces the singleton pattern with dependency injection while maintaining
@@ -254,6 +256,42 @@ class PluginRegistry(Generic[T]):
         except ValueError:
             raise AttributeError(f"module {module_name!r} has no attribute {attr_name!r}")
 
+    @classmethod
+    def default(cls) -> "PluginRegistry[T]":
+        """
+        Process-default registry. Prefer DI; use this only at the edge.
+        
+        Provides thread-safe lazy initialization of default instances per-subclass.
+        Each subclass gets its own default instance cache.
+        """
+        # Use a class-level cache stored in the subclass's __dict__
+        cache_key = "_default_instance"
+        lock_key = "_default_instance_lock"
+        
+        # Get or create lock in subclass __dict__ (not shared across inheritance hierarchy)
+        if lock_key not in cls.__dict__:
+            # Thread-safe initialization of the per-subclass lock itself
+            with PluginRegistry._default_locks_guard:
+                if lock_key not in cls.__dict__:
+                    # Store directly in the class __dict__ to avoid inheritance sharing
+                    setattr(cls, lock_key, threading.Lock())
+        
+        lock = getattr(cls, lock_key)
+        
+        # Check cache first (without lock for performance)
+        cache = cls.__dict__.get(cache_key)
+        if cache is not None:
+            return cache
+        
+        # Double-checked locking pattern
+        with lock:
+            cache = cls.__dict__.get(cache_key)
+            if cache is None:
+                cache = cls()
+                # Store directly in the class __dict__ to ensure per-subclass isolation
+                setattr(cls, cache_key, cache)
+            return cache
+
 
 def create_lazy_getattr(registry: PluginRegistry[T]) -> Callable[[str], T]:
     """Create a __getattr__ function backed by a PluginRegistry.

{praisonai-4.6.53 → praisonai-4.6.55}/praisonai/agents_generator.py

@@ -235,8 +235,9 @@ class AgentsGenerator:
         # CLI users get the process default.
         self._adapter_registry = adapter_registry or get_default_registry()
         
-        # Get framework adapter (availability already validated at CLI entry)
-        self.framework_adapter = self._get_framework_adapter(framework)
+        # Defer framework adapter creation until YAML is loaded
+        # This fixes the issue where empty framework string fails before YAML framework is read
+        self.framework_adapter = None
 
     def _get_framework_adapter(self, framework: str) -> FrameworkAdapter:
         """
@@ -281,7 +282,7 @@ class AgentsGenerator:
                 self.logger.debug(f"CLI override: lsp = {cli_config['lsp']}")
         
         # Handle agent-level overrides using unified approach
-        agent_level_fields = ['tool_timeout', 'planning_tools', 'autonomy', 'planning', 'web', 'web_fetch']
+        agent_level_fields = ['tool_timeout', 'tool_retry_policy', 'planning_tools', 'autonomy', 'planning', 'web', 'web_fetch']
         agent_overrides = {k: v for k, v in cli_config.items() if k in agent_level_fields}
         
         # Handle handoff configuration - convert CLI flags into handoff dict
@@ -343,6 +344,168 @@ class AgentsGenerator:
                     agent_config[field] = value
                     self.logger.debug(f"CLI override for agent {agent_name}: {field} = {value}")
 
+    def _prepare_for_run(self, config):
+        """
+        Single source of truth for YAML normalisation, validation,
+        CLI-backend compatibility, tool resolution, AutoGen version
+        selection, and adapter resolution. Used by BOTH sync and async.
+        """
+        # Canonical format conversion: 'agents' -> 'roles', 'instructions' -> 'backstory'
+        if 'agents' in config and 'roles' not in config:
+            config['roles'] = {}
+            for agent_name, agent_config in config['agents'].items():
+                role_config = dict(agent_config) if agent_config else {}
+                # Convert 'instructions' to 'backstory' if present
+                if 'instructions' in role_config and 'backstory' not in role_config:
+                    role_config['backstory'] = role_config['instructions']
+                # Ensure required fields have defaults
+                if 'role' not in role_config:
+                    role_config['role'] = agent_name.replace('_', ' ').title()
+                if 'goal' not in role_config:
+                    role_config['goal'] = role_config.get('backstory', 'Complete the assigned task')
+                if 'backstory' not in role_config:
+                    role_config['backstory'] = f'You are a {role_config["role"]}'
+                config['roles'][agent_name] = role_config
+
+        # Get workflow input: 'input' is canonical, 'topic' is alias for backward compatibility
+        topic = config.get('input', config.get('topic', ''))
+        
+        # Validate agents configuration for typos in field names
+        self._validate_agents_config(config)
+        
+        # Build tools dictionary using shared logic
+        tools_dict = self._build_tools_dict(config)
+        
+        # Select framework with AutoGen version logic
+        framework = self._select_autogen_version(
+            self.framework or config.get('framework', 'praisonai'),
+            config,
+        )
+        
+        # Get and resolve adapter
+        adapter = self._get_framework_adapter(framework).resolve()
+        
+        # Validate framework availability
+        from .framework_adapters.validators import assert_framework_available
+        assert_framework_available(adapter.name)
+        
+        # Validate cli_backend compatibility
+        self._validate_cli_backend_compatibility(config, framework)
+        
+        # Initialize observability hooks
+        from .observability.hooks import init_observability
+        init_observability(adapter.name)
+        
+        # Run adapter setup hooks
+        adapter.setup(framework_tag=adapter.name)
+        
+        # Update framework reference if resolution changed it
+        self.framework = adapter.name
+        self.framework_adapter = adapter
+        
+        return {
+            'adapter': adapter,
+            'config': config,
+            'topic': topic,
+            'tools_dict': tools_dict,
+        }
+    
+    def _build_tools_dict(self, config):
+        """Shared tool resolution logic for sync and async paths."""
+        tools_dict = {}
+        
+        # Demand-driven tool resolution - only resolve tools actually used in YAML
+        if is_available("crewai") or is_available("autogen") or is_available("praisonaiagents") or is_available("ag2"):
+            try:
+                # Collect all tool names mentioned in the YAML config
+                needed_tools: set[str] = set()
+                for role_cfg in config.get('roles', {}).values():
+                    for t in role_cfg.get('tools') or []:
+                        if isinstance(t, str) and t.strip():
+                            needed_tools.add(t.strip())
+                    for task_cfg in (role_cfg.get('tasks') or {}).values():
+                        if not isinstance(task_cfg, dict):
+                            continue
+                        for t in task_cfg.get('tools') or []:
+                            if isinstance(t, str) and t.strip():
+                                needed_tools.add(t.strip())
+
+                # Resolve only the tools actually referenced in YAML
+                for tool_name in needed_tools:
+                    try:
+                        resolved_tool = self.tool_resolver.resolve(tool_name)
+                        if resolved_tool is None:
+                            self.logger.warning(f"Tool '{tool_name}' not found")
+                            continue
+                        tools_dict[tool_name] = (
+                            resolved_tool() if inspect.isclass(resolved_tool) else resolved_tool
+                        )
+                    except Exception as e:
+                        self.logger.warning(f"Failed to initialize tool '{tool_name}': {e}")
+                        continue
+                            
+            except Exception as e:
+                self.logger.warning(f"Error collecting YAML tool references: {e}")
+            
+            # Add tools from class names - use tool_resolver to check tool validity
+            for tool_class in self.tools:
+                if isinstance(tool_class, type):
+                    try:
+                        tool_instance = tool_class()
+                        tool_name = tool_class.__name__
+                        tools_dict[tool_name] = tool_instance
+                        self.logger.debug(f"Added tool: {tool_name}")
+                    except Exception as e:
+                        self.logger.warning(f"Failed to instantiate tool class {tool_class.__name__}: {e}")
+
+        root_directory = os.getcwd()
+        tools_py_path = os.path.join(root_directory, 'tools.py')
+        tools_dir_path = Path(root_directory) / 'tools'
+        
+        # Use consolidated ToolResolver for tools.py loading
+        tools_dict.update(self.tool_resolver.get_local_tool_classes())
+        if os.path.isfile(tools_py_path):
+            self.logger.debug("tools.py exists in the root directory. Loading tools.py and skipping tools folder.")
+        elif tools_dir_path.is_dir():
+            tools_dict.update(self.tool_resolver.get_local_tool_classes_from_dir(tools_dir_path))
+            if tools_dict:
+                self.logger.debug("tools folder exists in the root directory")
+        
+        return tools_dict
+    
+    def _select_autogen_version(self, framework, config):
+        """Shared AutoGen version selection logic for sync and async paths."""
+        if framework == "autogen":
+            autogen_v4_adapter = self._get_framework_adapter("autogen_v4")
+            autogen_v2_adapter = self._get_framework_adapter("autogen")
+            
+            autogen_version = str(
+                config.get('autogen_version', os.environ.get("AUTOGEN_VERSION", "auto"))
+            ).lower()
+            use_v4 = False
+            
+            if autogen_version == "v0.4" and autogen_v4_adapter.is_available():
+                use_v4 = True
+            elif autogen_version == "v0.2" and autogen_v2_adapter.is_available():
+                use_v4 = False
+            elif autogen_version == "auto":
+                use_v4 = autogen_v4_adapter.is_available()
+            else:
+                use_v4 = autogen_v4_adapter.is_available() and not autogen_v2_adapter.is_available()
+            
+            framework = "autogen_v4" if use_v4 else "autogen"
+        
+        # Initialize AgentOps if configured
+        agentops_api_key = os.getenv("AGENTOPS_API_KEY")
+        if agentops_api_key:
+            try:
+                import agentops
+                agentops.init(agentops_api_key, default_tags=[framework])
+            except ImportError:
+                pass
+        
+        return framework
+    
     def _validate_cli_backend_compatibility(self, config, framework):
         """Validate that cli_backend is only used with compatible frameworks."""
         # Check if any agent/role defines cli_backend (support both key names)
@@ -375,8 +538,8 @@ class AgentsGenerator:
             'role', 'goal', 'instructions', 'backstory', 'tools', 'toolsets', 'tasks', 'llm',
             'function_calling_llm', 'allow_delegation', 'max_iter', 'max_rpm',
             'max_execution_time', 'verbose', 'cache', 'system_template',
-            'prompt_template', 'response_template', 'tool_timeout', 'planning_tools',
-            'planning', 'autonomy', 'guardrails', 'streaming', 'stream',
+            'prompt_template', 'response_template', 'tool_timeout', 'tool_retry_policy',
+            'planning_tools', 'planning', 'autonomy', 'guardrails', 'streaming', 'stream',
             'approval', 'skills', 'cli_backend', 'reflection', 'handoff', 'web', 'web_fetch'
         }
 
@@ -512,141 +675,19 @@ class AgentsGenerator:
             # Route to YAMLWorkflowParser for advanced workflow patterns
             return self._run_yaml_workflow(config)
 
-        config, adapter, tools_dict, topic = self._prepare(config)
-        return adapter.run(
-            config,
+        # Use shared preparation logic
+        prep = self._prepare_for_run(config)
+        
+        self.logger.info(f"Using framework: {prep['adapter'].name}")
+        return prep['adapter'].run(
+            prep['config'],
             self.config_list,
-            topic,
-            tools_dict=tools_dict,
+            prep['topic'],
+            tools_dict=prep['tools_dict'],
             agent_callback=getattr(self, 'agent_callback', None),
             task_callback=getattr(self, 'task_callback', None),
             cli_config=getattr(self, 'cli_config', None),
         )
-    
-    def _prepare(self, config):
-        """Shared preparation logic for both sync and async entry points."""
-        # Canonical format conversion: 'agents' -> 'roles', 'instructions' -> 'backstory'
-        if 'agents' in config and 'roles' not in config:
-            config['roles'] = {}
-            for agent_name, agent_config in config['agents'].items():
-                role_config = dict(agent_config) if agent_config else {}
-                if 'instructions' in role_config and 'backstory' not in role_config:
-                    role_config['backstory'] = role_config['instructions']
-                if 'role' not in role_config:
-                    role_config['role'] = agent_name.replace('_', ' ').title()
-                if 'goal' not in role_config:
-                    role_config['goal'] = role_config.get('backstory', 'Complete the assigned task')
-                if 'backstory' not in role_config:
-                    role_config['backstory'] = f'You are a {role_config["role"]}'
-                config['roles'][agent_name] = role_config
-
-        # Get workflow input: 'input' is canonical, 'topic' is alias for backward compatibility
-        topic = config.get('input', config.get('topic', ''))
-        
-        # Validate agents configuration for typos in field names
-        self._validate_agents_config(config)
-        
-        tools_dict = {}
-        
-        # Demand-driven tool resolution - only resolve tools actually used in YAML
-        if is_available("crewai") or is_available("autogen") or is_available("praisonaiagents") or is_available("ag2"):
-            try:
-                # Collect all tool names mentioned in the YAML config
-                needed_tools: set[str] = set()
-                for role_cfg in config.get('roles', {}).values():
-                    for t in role_cfg.get('tools') or []:
-                        if isinstance(t, str) and t.strip():
-                            needed_tools.add(t.strip())
-                    for task_cfg in (role_cfg.get('tasks') or {}).values():
-                        if not isinstance(task_cfg, dict):
-                            continue
-                        for t in task_cfg.get('tools') or []:
-                            if isinstance(t, str) and t.strip():
-                                needed_tools.add(t.strip())
-
-                # Resolve only the tools actually referenced in YAML
-                for tool_name in needed_tools:
-                    try:
-                        resolved_tool = self.tool_resolver.resolve(tool_name, instantiate=True)
-                        if resolved_tool is not None:
-                            tools_dict[tool_name] = resolved_tool
-                    except Exception as e:
-                        self.logger.warning(f"Failed to initialize tool '{tool_name}': {e}")
-                        continue
-
-            except Exception as e:
-                self.logger.warning(f"Error collecting YAML tool references: {e}")
-
-            # Add tools from class names - use tool_resolver to check tool validity
-            for tool_class in self.tools:
-                if isinstance(tool_class, type):
-                    try:
-                        tool_instance = tool_class()
-                        tool_name = tool_class.__name__
-                        tools_dict[tool_name] = tool_instance
-                        self.logger.debug(f"Added tool: {tool_name}")
-                    except Exception as e:
-                        self.logger.warning(f"Failed to instantiate tool class {tool_class.__name__}: {e}")
-
-        root_directory = os.getcwd()
-        tools_py_path = os.path.join(root_directory, 'tools.py')
-        tools_dir_path = Path(root_directory) / 'tools'
-
-        # Use consolidated ToolResolver for tools.py loading
-        tools_dict.update(self.tool_resolver.get_local_tool_classes())
-        if os.path.isfile(tools_py_path):
-            self.logger.debug("tools.py exists in the root directory. Loading tools.py and skipping tools folder.")
-        elif tools_dir_path.is_dir():
-            tools_dict.update(self.tool_resolver.get_local_tool_classes_from_dir(tools_dir_path))
-            if tools_dict:
-                self.logger.debug("tools folder exists in the root directory")
-
-        framework = self.framework or config.get('framework', 'crewai')
-        
-        # AutoGen version selection logic
-        if framework == "autogen":
-            autogen_v4_adapter = self._get_framework_adapter("autogen_v4")
-            autogen_v2_adapter = self._get_framework_adapter("autogen")
-            
-            autogen_version = str(
-                config.get('autogen_version', os.environ.get("AUTOGEN_VERSION", "auto"))
-            ).lower()
-            use_v4 = False
-            
-            if autogen_version == "v0.4" and autogen_v4_adapter.is_available():
-                use_v4 = True
-            elif autogen_version == "v0.2" and autogen_v2_adapter.is_available():
-                use_v4 = False
-            elif autogen_version == "auto":
-                use_v4 = autogen_v4_adapter.is_available()
-            else:
-                use_v4 = autogen_v4_adapter.is_available() and not autogen_v2_adapter.is_available()
-            
-            framework = "autogen_v4" if use_v4 else "autogen"
-
-        # Validate cli_backend compatibility
-        self._validate_cli_backend_compatibility(config, framework)
-        
-        # Get framework adapter and resolve to concrete variant
-        adapter = self._get_framework_adapter(framework).resolve()
-        
-        # Validate framework availability early
-        from .framework_adapters.validators import assert_framework_available
-        assert_framework_available(adapter.name)
-        
-        # Initialize observability hooks
-        from .observability.hooks import init_observability
-        init_observability(adapter.name)
-        
-        # Run adapter setup hooks
-        adapter.setup(framework_tag=adapter.name)
-        
-        # Update framework reference if resolution changed it
-        self.framework = adapter.name
-        self.framework_adapter = adapter
-        
-        self.logger.info(f"Using framework: {adapter.name}")
-        return config, adapter, tools_dict, topic
 
     async def agenerate_crew_and_kickoff(self):
         """
@@ -682,12 +723,15 @@ class AgentsGenerator:
 
     async def _arun_framework(self, config):
         """Async version of _run_framework with shared preparation logic."""
-        config, adapter, tools_dict, topic = self._prepare(config)
-        return await adapter.arun(
-            config,
+        # Use shared preparation logic
+        prep = self._prepare_for_run(config)
+        
+        self.logger.info(f"Using framework: {prep['adapter'].name}")
+        return await prep['adapter'].arun(
+            prep['config'],
             self.config_list,
-            topic,
-            tools_dict=tools_dict,
+            prep['topic'],
+            tools_dict=prep['tools_dict'],
             agent_callback=getattr(self, 'agent_callback', None),
             task_callback=getattr(self, 'task_callback', None),
             cli_config=getattr(self, 'cli_config', None),

{praisonai-4.6.53 → praisonai-4.6.55}/praisonai/bots/email.py

@@ -419,11 +419,13 @@ class EmailBot(ChatCommandMixin, MessageHookMixin):
         reply_to: Optional[str] = None,
         thread_id: Optional[str] = None,
     ) -> BotMessage:
-        """Send an email message.
+        """Send an email message with optional CC and BCC recipients.
         
         Args:
             channel_id: Recipient email address
-            content: Message content (str or {"subject": ..., "body": ...})
+            content: Message content. Can be:
+                - str: Plain text message body
+                - dict: {"subject": str, "body": str, "html": str, "cc": str/list, "bcc": str/list}
             reply_to: Message-ID to reply to (sets In-Reply-To header)
             thread_id: References chain (sets References header)
             
@@ -439,10 +441,14 @@ class EmailBot(ChatCommandMixin, MessageHookMixin):
             subject = content.get("subject", "Message from PraisonAI")
             body = content.get("body", "")
             html = content.get("html")
+            cc = content.get("cc")
+            bcc = content.get("bcc")
         else:
             subject = "Message from PraisonAI"
             body = str(content)
             html = None
+            cc = None
+            bcc = None
         
         # Build email
         if html:
@@ -456,6 +462,18 @@ class EmailBot(ChatCommandMixin, MessageHookMixin):
         msg["To"] = channel_id
         msg["Subject"] = subject
         
+        # Add CC and BCC headers if provided
+        from praisonaiagents.tools.email_tools import _parse_email_list
+        all_recipients = [channel_id]
+        if cc:
+            cc_list = _parse_email_list(cc)
+            msg["CC"] = ", ".join(cc_list)
+            all_recipients.extend(cc_list)
+        if bcc:
+            bcc_list = _parse_email_list(bcc)
+            all_recipients.extend(bcc_list)
+            # Note: BCC is not added to headers (by design)
+        
         # Generate unique Message-ID
         domain = self._email_address.split("@")[-1]
         message_id = f"<{hashlib.sha256(f'{time.time()}{channel_id}'.encode()).hexdigest()}@{domain}>"
@@ -473,7 +491,7 @@ class EmailBot(ChatCommandMixin, MessageHookMixin):
         
         # Send via SMTP
         loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, self._send_smtp, msg)
+        await loop.run_in_executor(None, self._send_smtp, msg, all_recipients)
         
         # Create BotMessage for return
         bot_message = BotMessage(
@@ -492,12 +510,12 @@ class EmailBot(ChatCommandMixin, MessageHookMixin):
         
         return bot_message
     
-    def _send_smtp(self, msg: MIMEText) -> None:
+    def _send_smtp(self, msg: MIMEText, to_addrs: List[str]) -> None:
         """Send email via SMTP (sync, runs in executor)."""
         with smtplib.SMTP(self._smtp_server, self._smtp_port) as server:
             server.starttls()
             server.login(self._email_address, self._token)
-            server.send_message(msg)
+            server.send_message(msg, to_addrs=to_addrs)
     
     async def edit_message(
         self,

{praisonai-4.6.53 → praisonai-4.6.55}/praisonai/cli/main.py

@@ -989,6 +989,7 @@ class PraisonAI:
         # Memory arguments
         parser.add_argument("--memory", action="store_true", help="Enable file-based memory for agent")
         parser.add_argument("--user-id", type=str, help="User ID for memory isolation")
+        parser.add_argument("--message-steering", action="store_true", help="Enable real-time message steering for agents during execution")
         
         # Session management arguments
         parser.add_argument("--auto-save", type=str, metavar="NAME", help="Auto-save session with given name after each run")
@@ -1095,6 +1096,16 @@ class PraisonAI:
         parser.add_argument("--tool-timeout", type=int, default=60,
                           help="Timeout in seconds for each tool call (default: 60)")
         
+        # Tool retry policy - handle transient failures with exponential backoff
+        parser.add_argument("--tool-retry-attempts", type=int, default=3,
+                          help="Maximum retry attempts for tool failures (default: 3)")
+        parser.add_argument("--tool-retry-delay", type=int, default=1000,
+                          help="Initial retry delay in milliseconds (default: 1000)")
+        parser.add_argument("--tool-retry-backoff", type=float, default=2.0,
+                          help="Retry backoff multiplier (default: 2.0)")
+        parser.add_argument("--tool-retry-on", type=str, default="timeout,rate_limit,connection_error",
+                          help="Error types to retry (comma-separated, default: timeout,rate_limit,connection_error)")
+        
         # Tool Approval - control tool execution approval
         parser.add_argument("--trust", action="store_true", help="Auto-approve all tool executions (skip approval prompts)")
         parser.add_argument("--approve-level", type=str, choices=["low", "medium", "high", "critical"], 
@@ -4137,6 +4148,22 @@ Do NOT add any explanations or formatting."""
         tool_timeout = getattr(self.args, 'tool_timeout', None)
         if tool_timeout is not None:
             cli_config['tool_timeout'] = tool_timeout
+        
+        # Extract --tool-retry-* flags for retry policy
+        retry_attempts = getattr(self.args, 'tool_retry_attempts', 3)
+        retry_delay = getattr(self.args, 'tool_retry_delay', 1000)
+        retry_backoff = getattr(self.args, 'tool_retry_backoff', 2.0)
+        retry_on_str = getattr(self.args, 'tool_retry_on', "timeout,rate_limit,connection_error")
+        retry_on = set(error_type.strip() for error_type in retry_on_str.split(',') if error_type.strip())
+        
+        if retry_attempts > 1:  # Only create retry policy if retries are enabled
+            from praisonaiagents.tools.retry import RetryPolicy
+            cli_config['tool_retry_policy'] = RetryPolicy(
+                max_attempts=retry_attempts,
+                initial_delay_ms=retry_delay,
+                backoff_factor=retry_backoff,
+                retry_on=retry_on
+            )
             
         # Extract --planning-tools flag
         planning_tools = getattr(self.args, 'planning_tools', None)
@@ -4395,6 +4422,22 @@ Do NOT add any explanations or formatting."""
                 if tool_timeout and tool_timeout > 0:
                     agent_config["tool_timeout"] = tool_timeout
                 
+                # Tool retry policy - handle transient failures with exponential backoff
+                retry_attempts = getattr(self.args, 'tool_retry_attempts', 3)
+                retry_delay = getattr(self.args, 'tool_retry_delay', 1000)
+                retry_backoff = getattr(self.args, 'tool_retry_backoff', 2.0)
+                retry_on_str = getattr(self.args, 'tool_retry_on', "timeout,rate_limit,connection_error")
+                retry_on = set(error_type.strip() for error_type in retry_on_str.split(',') if error_type.strip())
+                
+                if retry_attempts > 1:  # Only create retry policy if retries are enabled
+                    from praisonaiagents.tools.retry import RetryPolicy
+                    agent_config["tool_retry_policy"] = RetryPolicy(
+                        max_attempts=retry_attempts,
+                        initial_delay_ms=retry_delay,
+                        backoff_factor=retry_backoff,
+                        retry_on=retry_on
+                    )
+                
                 # Memory
                 if getattr(self.args, 'memory', False):
                     memory_kwargs = {}
@@ -4434,6 +4477,11 @@ Do NOT add any explanations or formatting."""
                     else:
                         print("[yellow]Warning: --claude-memory requires an Anthropic model (--llm anthropic/...)[/yellow]")
                 
+                # Message Steering
+                if getattr(self.args, 'message_steering', False):
+                    agent_config["message_steering"] = True
+                    print("[bold cyan]Message steering enabled - agent can receive guidance during execution[/bold cyan]")
+                
                 # ===== NEW CLI FEATURES INTEGRATION =====
                 
                 # Tool Approval - Auto-approve tools based on --trust or --approve-level