PraisonAI 4.6.50__tar.gz → 4.6.52__tar.gz

{praisonai-4.6.50 → praisonai-4.6.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.50
+Version: 4.6.52
 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.50
+Requires-Dist: praisonaiagents>=1.6.52
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.50 → praisonai-4.6.52}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.50
+Version: 4.6.52
 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.50
+Requires-Dist: praisonaiagents>=1.6.52
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.50 → praisonai-4.6.52}/PraisonAI.egg-info/SOURCES.txt

@@ -543,6 +543,7 @@ praisonai/integration/pages/workflow_runs.py
 praisonai/integrations/__init__.py
 praisonai/integrations/_session_info.py
 praisonai/integrations/_tool_aliases.py
+praisonai/integrations/_unified_registry.py
 praisonai/integrations/base.py
 praisonai/integrations/claude_code.py
 praisonai/integrations/codex_cli.py
@@ -610,6 +611,7 @@ praisonai/n8n/converter.py
 praisonai/n8n/preview.py
 praisonai/n8n/reverse_converter.py
 praisonai/observability/__init__.py
+praisonai/observability/hooks.py
 praisonai/observability/langextract.py
 praisonai/observability/langfuse.py
 praisonai/persistence/__init__.py
@@ -630,6 +632,7 @@ praisonai/persistence/conversation/singlestore.py
 praisonai/persistence/conversation/sqlite.py
 praisonai/persistence/conversation/supabase.py
 praisonai/persistence/conversation/surrealdb.py
+praisonai/persistence/conversation/sync_sqlite.py
 praisonai/persistence/conversation/turso.py
 praisonai/persistence/hooks/__init__.py
 praisonai/persistence/hooks/agent_hooks.py

{praisonai-4.6.50 → praisonai-4.6.52}/PraisonAI.egg-info/requires.txt

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

{praisonai-4.6.50 → praisonai-4.6.52}/praisonai/_registry.py

@@ -234,4 +234,59 @@ class PluginRegistry(Generic[T]):
             Sorted list of all registered names and aliases
         """
         with self._lock:
-            return sorted(list(self._loaders.keys()) + list(self._aliases.keys()))
+            return sorted(list(self._loaders.keys()) + list(self._aliases.keys()))
+    
+    def get_by_attr(self, module_name: str, attr_name: str) -> Type[T]:
+        """Get a plugin by attribute name for __getattr__ dispatch.
+        
+        Args:
+            module_name: Module name requesting the attribute (for error messages)
+            attr_name: Attribute name to resolve
+            
+        Returns:
+            Plugin class
+            
+        Raises:
+            AttributeError: If plugin is not found
+        """
+        try:
+            return self.resolve(attr_name)
+        except ValueError:
+            raise AttributeError(f"module {module_name!r} has no attribute {attr_name!r}")
+
+
+def create_lazy_getattr(registry: PluginRegistry[T]) -> Callable[[str], T]:
+    """Create a __getattr__ function backed by a PluginRegistry.
+    
+    This replaces manual if/elif ladders in __init__.py files with a data-driven
+    approach using the plugin registry.
+    
+    Args:
+        registry: The plugin registry to use for resolution
+        
+    Returns:
+        Function that can be used as __getattr__ in a module
+        
+    Example:
+        # In __init__.py:
+        from ._registry import create_lazy_getattr
+        
+        # Assuming you have a registry instance
+        __getattr__ = create_lazy_getattr(my_registry)
+    """
+    def __getattr__(name: str) -> T:
+        try:
+            plugin_class = registry.resolve(name)
+            return plugin_class
+        except ValueError:
+            # Get the calling module name for error context
+            import inspect
+            frame = inspect.currentframe()
+            if frame and frame.f_back:
+                module_name = frame.f_back.f_globals.get('__name__', 'unknown')
+            else:
+                module_name = 'unknown'
+            
+            raise AttributeError(f"module {module_name!r} has no attribute {name!r}")
+    
+    return __getattr__

{praisonai-4.6.50 → praisonai-4.6.52}/praisonai/agents_generator.py

@@ -653,14 +653,163 @@ class AgentsGenerator:
                 self.logger.debug("tools folder exists in the root directory")
 
         framework = self.framework or config.get('framework', 'crewai')
+        
+        # Get initial adapter and resolve to concrete variant
+        initial_adapter = self._get_framework_adapter(framework)
+        adapter = initial_adapter.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 adapter.run(
+            config,
+            self.config_list,
+            topic,
+            tools_dict=tools_dict,
+            agent_callback=getattr(self, 'agent_callback', None),
+            task_callback=getattr(self, 'task_callback', None),
+            cli_config=getattr(self, 'cli_config', None),
+        )
+
+    async def agenerate_crew_and_kickoff(self):
+        """
+        Async version of generate_crew_and_kickoff.
+        Generates a crew of agents and initiates tasks based on the provided configuration.
+        """
+        if self.agent_yaml:
+            config = yaml.safe_load(self.agent_yaml)
+        else:
+            if self.agent_file == '/app/api:app' or self.agent_file == 'api:app':
+                self.agent_file = 'agents.yaml'
+            try:
+                with open(self.agent_file, 'r') as f:
+                    config = yaml.safe_load(f)
+            except FileNotFoundError:
+                print(f"File not found: {self.agent_file}")
+                return
 
-        # Determine AutoGen version if needed (keeping compatibility logic)
+        # Apply CLI configuration overrides to YAML config
+        if self.cli_config:
+            # Merge CLI configuration with YAML config
+            self._merge_cli_config(config, self.cli_config)
+
+        # Check if this is a workflow-mode YAML (process: workflow or has steps section)
+        process_type = config.get('process', 'sequential')
+        has_steps = 'steps' in config
+        has_workflow_config = 'workflow' in config
+        
+        if process_type == 'workflow' or (has_steps and has_workflow_config):
+            return await self._arun_yaml_workflow(config)
+        else:
+            return await self._arun_framework(config)
+
+    async def _arun_framework(self, config):
+        """Async version of _run_framework with shared preparation logic."""
+        # 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)
+                        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")
+
+        framework = self.framework or config.get('framework', 'crewai')
+        
+        # AutoGen version selection logic
         if framework == "autogen":
-            autogen_version = os.environ.get("AUTOGEN_VERSION", "auto").lower()
             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():
@@ -671,27 +820,27 @@ class AgentsGenerator:
                 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 available
-        try:
-            import agentops
-            agentops_api_key = os.getenv("AGENTOPS_API_KEY")
-            if agentops_api_key:
+
+        # 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
-            
-        # Update framework adapter if framework changed (e.g., AutoGen version selection)
+            except ImportError:
+                pass
+                
+        # Update framework adapter if framework changed
         if framework != self.framework:
             self.framework = framework
             self.framework_adapter = self._get_framework_adapter(framework)
             
-        # Validate framework availability for non-CLI callers
+        # Validate framework availability
         from .framework_adapters.validators import assert_framework_available
         assert_framework_available(framework)
         
         self.logger.info(f"Using framework: {framework}")
-        return self.framework_adapter.run(
+        return await self.framework_adapter.arun(
             config,
             self.config_list,
             topic,
@@ -701,6 +850,12 @@ class AgentsGenerator:
             cli_config=getattr(self, 'cli_config', None),
         )
 
+    async def _arun_yaml_workflow(self, config):
+        """Async placeholder for workflow mode - currently delegates to sync version."""
+        # For now, delegate to sync version using asyncio.to_thread
+        import asyncio
+        return await asyncio.to_thread(self._run_yaml_workflow, config)
+
     def _run_yaml_workflow(self, config):
         """
         Run a YAML workflow using the YAMLWorkflowParser.

{praisonai-4.6.50 → praisonai-4.6.52}/praisonai/bots/_session.py

@@ -149,15 +149,17 @@ class BotSessionManager:
         if self._store is not None:
             key = self._session_key(user_id)
             try:
-                # Clear existing and re-write (atomic update)
-                self._store.clear_session(key)
-                for msg in history:
-                    self._store.add_message(
-                        key,
-                        msg.get("role", "user"),
-                        msg.get("content", ""),
-                        msg.get("metadata"),
-                    )
+                if hasattr(self._store, "set_chat_history"):
+                    self._store.set_chat_history(key, history)
+                else:
+                    self._store.clear_session(key)
+                    for msg in history:
+                        self._store.add_message(
+                            key,
+                            msg.get("role", "user"),
+                            msg.get("content", ""),
+                            msg.get("metadata"),
+                        )
             except Exception as e:
                 logger.warning("Failed to persist session to store: %s", e)
 

{praisonai-4.6.50 → praisonai-4.6.52}/praisonai/bots/telegram.py

@@ -181,37 +181,10 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
         )
         
         async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
-            # Handle text OR audio messages
-            message_text = None
-            
-            if update.message:
-                # Check for voice/audio first
-                if update.message.voice or update.message.audio:
-                    message_text = await self._transcribe_audio(update)
-                elif update.message.text:
-                    message_text = update.message.text
-            
-            if not update.message or not message_text:
-                return
-            
-            message = self._convert_update_to_message(update, override_text=message_text)
-            
-            # Add channel type for pairing system
-            message._channel_type = "telegram"
-            
-            self.fire_message_received(message)
-            
-            # Check if channel is allowed
-            if not self.config.is_channel_allowed(message.channel.channel_id if message.channel else ""):
-                return
-            
-            # Handle unknown users with pairing system
-            user_id = message.sender.user_id if message.sender else ""
-            is_explicitly_allowed = bool(self.config.allowed_users) and self.config.is_user_allowed(user_id)
-            if not is_explicitly_allowed:
-                user_allowed = await UnknownUserHandler.handle(message, self._bot_context)
-                if not user_allowed:
-                    return
+            # Use shared security pipeline for consistent enforcement
+            message = await process_inbound_telegram_message(update, self)
+            if not message:
+                return  # Message was dropped by security checks
             
             for handler in self._message_handlers:
                 try:
@@ -252,7 +225,7 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
                     update.message.from_user.username or update.message.from_user.first_name or ""
                 ) if update.message.from_user else ""
                 try:
-                    message_text = await self._debouncer.debounce(user_id, message_text)
+                    message_text = await self._debouncer.debounce(user_id, message.content)
                     
                     # Show typing indicator with renewal during long operation
                     if self.config.typing_indicator:
@@ -848,3 +821,114 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
         except Exception as e:
             logger.error(f"Failed to send reply: {e}")
 
+
+async def process_inbound_telegram_message(
+    update,  # Telegram Update
+    bot: TelegramBot,
+    gateway_context: Optional[Dict] = None
+) -> Optional[BotMessage]:
+    """
+    Shared security pipeline for processing inbound Telegram messages.
+    
+    Used by both standalone bot (TelegramBot.handle_message) and 
+    gateway polling (_start_telegram_bot_polling) to ensure consistent
+    access control enforcement.
+    
+    Args:
+        update: Telegram Update object
+        bot: TelegramBot instance with config and security settings
+        gateway_context: Optional dict with gateway-specific context
+        
+    Returns:
+        BotMessage if message passes all security checks, None if dropped
+    """
+    if not update.message:
+        return None
+    
+    # Extract message text (including audio transcription)
+    message_text = None
+    if update.message.voice or update.message.audio:
+        message_text = await bot._transcribe_audio(update)
+    elif update.message.text:
+        message_text = update.message.text
+    
+    if not message_text:
+        return None
+    
+    # Convert to BotMessage for consistent processing
+    message = bot._convert_update_to_message(update, override_text=message_text)
+    
+    # Set channel type for pairing system
+    message._channel_type = "telegram"
+    
+    # Fire message received event
+    bot.fire_message_received(message)
+    
+    # 1. Channel allowlist check
+    channel_id = message.channel.channel_id if message.channel else ""
+    if not bot.config.is_channel_allowed(channel_id):
+        logger.debug(f"Message dropped: channel {channel_id} not in allowed_channels")
+        return None
+    
+    # 2. User allowlist and pairing check
+    user_id = message.sender.user_id if message.sender else ""
+    is_explicitly_allowed = bot.config.is_user_allowed(user_id)
+    
+    if not is_explicitly_allowed:
+        # Check if bot context is available for pairing system
+        if not hasattr(bot, '_bot_context') or bot._bot_context is None:
+            # For gateway mode, we need to create bot context on demand
+            if not hasattr(bot, '_pairing_store'):
+                from ..gateway.pairing import PairingStore
+                bot._pairing_store = PairingStore()
+            
+            bot._bot_context = BotContext(
+                config=bot.config,
+                pairing_store=bot._pairing_store,
+                adapter=bot
+            )
+        
+        user_allowed = await UnknownUserHandler.handle(message, bot._bot_context)
+        if not user_allowed:
+            logger.debug(f"Message dropped: user {user_id} not allowed by pairing system")
+            return None
+    
+    # 3. Group policy enforcement
+    if message.channel and message.channel.channel_type not in ("dm", "private"):
+        # This is a group/channel message, check group policies
+        group_policy = getattr(bot.config, 'group_policy', 'mention_only')
+        mention_required = getattr(bot.config, 'mention_required', True)
+        
+        if group_policy == "command_only":
+            if message.message_type != MessageType.COMMAND:
+                logger.debug(f"Message dropped: non-command in command_only group {channel_id}")
+                return None
+        elif group_policy == "mention_only":
+            # Check if bot was mentioned in the message
+            bot_username = bot._bot_user.username.lower() if bot._bot_user and bot._bot_user.username else ""
+            mention_handle = f"@{bot_username}" if bot_username else ""
+            bot_mentioned = (
+                mention_handle and mention_handle in message.content.lower()
+            ) or message.message_type == MessageType.COMMAND  # Commands are always allowed
+            
+            if not bot_mentioned:
+                logger.debug(f"Message dropped: bot not mentioned in group {channel_id}")
+                return None
+        elif group_policy == "respond_all":
+            # Allow all group messages
+            pass
+        elif mention_required:
+            # Fallback for backward compatibility when group_policy is not set
+            bot_username = bot._bot_user.username.lower() if bot._bot_user and bot._bot_user.username else ""
+            mention_handle = f"@{bot_username}" if bot_username else ""
+            bot_mentioned = (
+                mention_handle and mention_handle in message.content.lower()
+            ) or message.message_type == MessageType.COMMAND  # Commands are always allowed
+            
+            if not bot_mentioned:
+                logger.debug(f"Message dropped: bot not mentioned in group {channel_id}")
+                return None
+    
+    # All security checks passed
+    logger.debug(f"Message security checks passed for user {user_id} in channel {channel_id}")
+    return message