PraisonAI 4.6.129__tar.gz → 4.6.131__tar.gz

{praisonai-4.6.129 → praisonai-4.6.131}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.129
+Version: 4.6.131
 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,9 +11,9 @@ 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.132
-Requires-Dist: praisonai-code>=0.0.28
-Requires-Dist: praisonai-bot>=0.0.13
+Requires-Dist: praisonaiagents>=1.6.134
+Requires-Dist: praisonai-code>=0.0.30
+Requires-Dist: praisonai-bot>=0.0.15
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.129 → praisonai-4.6.131}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.129
+Version: 4.6.131
 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,9 +11,9 @@ 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.132
-Requires-Dist: praisonai-code>=0.0.28
-Requires-Dist: praisonai-bot>=0.0.13
+Requires-Dist: praisonaiagents>=1.6.134
+Requires-Dist: praisonai-code>=0.0.30
+Requires-Dist: praisonai-bot>=0.0.15
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.129 → praisonai-4.6.131}/PraisonAI.egg-info/requires.txt

@@ -1,9 +1,9 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.132
-praisonai-code>=0.0.28
-praisonai-bot>=0.0.13
+praisonaiagents>=1.6.134
+praisonai-code>=0.0.30
+praisonai-bot>=0.0.15
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.129 → praisonai-4.6.131}/praisonai/agents_generator.py

@@ -596,7 +596,7 @@ class AgentsGenerator:
         assert_framework_available(adapter.name)
         
         # Validate cli_backend compatibility
-        self._validate_cli_backend_compatibility(config, adapter.name)
+        self._validate_cli_backend_compatibility(config, adapter.name, adapter=adapter)
         
         # Initialize observability hooks
         from .observability.hooks import init_observability
@@ -676,7 +676,7 @@ class AgentsGenerator:
         
         return resolved_adapter
     
-    def _validate_cli_backend_compatibility(self, config, framework):
+    def _validate_cli_backend_compatibility(self, config, framework, *, adapter=None):
         """Validate that cli_backend and runtime are only used with compatible frameworks."""
         # Check if any agent/role defines cli_backend or runtime
         all_entities = {
@@ -712,7 +712,26 @@ class AgentsGenerator:
                 for provider_config in providers_config.values()
             )
         
-        if (has_cli_backend or has_runtime or has_model_runtime or has_provider_runtime) and framework != 'praisonai':
+        # Ask the adapter whether it supports runtime features instead of
+        # hardcoding a framework-name check. Third-party adapters can opt in by
+        # setting ``SUPPORTS_RUNTIME_FEATURES = True``. Fall back to resolving
+        # the adapter from the registry for callers that pass only a name.
+        if adapter is None:
+            try:
+                adapter = self._get_framework_adapter(framework)
+            except Exception:
+                adapter = None
+        if adapter is not None:
+            supports_runtime_features = bool(
+                getattr(adapter, "SUPPORTS_RUNTIME_FEATURES", False)
+            )
+        else:
+            # Adapter could not be resolved (e.g. minimal/mock generator without a
+            # registry): preserve the historical native-only behaviour.
+            supports_runtime_features = str(framework).lower() == "praisonai"
+
+        if (has_cli_backend or has_runtime or has_model_runtime or has_provider_runtime) \
+                and not supports_runtime_features:
             runtime_features = []
             if has_cli_backend:
                 runtime_features.append('cli_backend')
@@ -724,12 +743,17 @@ class AgentsGenerator:
                 runtime_features.append('providers.*.runtime_default')
             
             features_str = ', '.join(runtime_features)
-            self.logger.error(
-                f"Runtime features ({features_str}) are not supported for framework='{framework}'. "
-                f"Remove these fields from your YAML or switch to framework='praisonai'."
-            )
+            logger = getattr(self, "logger", None)
+            if logger is not None:
+                logger.error(
+                    f"Runtime features ({features_str}) are not supported for framework='{framework}'. "
+                    f"Remove these fields from your YAML or switch to a framework whose adapter "
+                    f"sets SUPPORTS_RUNTIME_FEATURES = True (e.g. framework='praisonai')."
+                )
             raise ValueError(
-                f"Runtime features require framework='praisonai', but framework='{framework}' was specified"
+                f"Runtime features ({features_str}) are not supported for framework='{framework}'. "
+                f"Use a framework whose adapter sets SUPPORTS_RUNTIME_FEATURES = True "
+                f"(e.g. framework='praisonai')."
             )
 
     def _validate_agents_config(self, config):

{praisonai-4.6.129 → praisonai-4.6.131}/praisonai/auto.py

@@ -854,9 +854,14 @@ class AutoGenerator(BaseAutoGenerator):
         if requires_tools_extra and not is_available("praisonai_tools"):
             logger.warning(f"Tools are not available for {framework}. To use tools, install:\n    {install_hint}")
 
+        # Retain the resolved adapter as the canonical dispatch object (mirrors
+        # AgentsGenerator, which stores self.framework_adapter). Downstream code
+        # can consult it instead of only carrying a bare framework string.
+        self._adapter = adapter
         self.topic = topic
         self.agent_file = agent_file
-        self.framework = framework or "praisonai"
+        # Authoritative framework name comes from the adapter, not the raw arg.
+        self.framework = adapter.name or framework or "praisonai"
         self.pattern = pattern
         self.single_agent = single_agent
     
@@ -1019,14 +1024,65 @@ class AutoGenerator(BaseAutoGenerator):
         
         return merged_data
 
+    def _get_tool_resolver(self):
+        """Lazily construct the canonical ToolResolver (single source of truth).
+
+        Kept lazy so importing auto.py stays cheap and so a resolver-construction
+        failure never blocks generation — callers fall back to keyword hints.
+        """
+        resolver = getattr(self, "_tool_resolver", None)
+        if resolver is None:
+            try:
+                from .tool_resolver import ToolResolver
+                resolver = ToolResolver()
+            except Exception as e:  # pragma: no cover - defensive
+                logger.debug("ToolResolver unavailable (%s); using keyword hints only.", e)
+                resolver = False  # sentinel: attempted, not available
+            self._tool_resolver = resolver
+        return resolver or None
+
+    def _available_tools(self) -> List[str]:
+        """Return the real, installed tool names from the canonical ToolResolver.
+
+        This is the single source of truth shared with AgentsGenerator. Returns
+        an empty list if the resolver is unavailable so callers can fall back.
+        """
+        resolver = self._get_tool_resolver()
+        if resolver is None:
+            return []
+        try:
+            return sorted(resolver.list_available().keys())
+        except Exception as e:  # pragma: no cover - defensive
+            logger.debug("ToolResolver.list_available() failed (%s).", e)
+            return []
+
     def discover_tools_for_topic(self) -> List[str]:
         """
-        Discover appropriate tools for the topic using intelligent matching.
-        
-        Returns:
-            List of tool names appropriate for this topic
+        Discover appropriate tools for the topic.
+
+        Drives recommendations through the canonical ToolResolver (single source
+        of truth) so only tools that are actually installed are surfaced. Keyword
+        hints are used to prioritise, but the returned set is intersected with the
+        real registry when it is available, avoiding recommendations for tools the
+        user does not have. Falls back to keyword hints when the resolver cannot
+        be constructed.
         """
-        return get_tools_for_task(self.topic)
+        return self._discover_tools_for_topic(self._available_tools())
+
+    def _discover_tools_for_topic(self, available: List[str]) -> List[str]:
+        keyword_tools = get_tools_for_task(self.topic)
+        if not available:
+            # Resolver unavailable — preserve legacy keyword-only behaviour.
+            return keyword_tools
+
+        available_set = set(available)
+        # Prefer keyword-matched tools that actually exist, preserving order.
+        prioritized = [t for t in keyword_tools if t in available_set]
+        if prioritized:
+            return prioritized
+        # No keyword hit resolves to a real tool: surface the real registry so the
+        # LLM plans only with tools the user can actually run.
+        return available
     
     def get_user_content(self):
         """
@@ -1055,19 +1111,31 @@ class AutoGenerator(BaseAutoGenerator):
         
         workflow_guidance = pattern_guidance.get(self.pattern, pattern_guidance["sequential"])
         
+        # Resolve the installed tool registry once (single source of truth) and
+        # reuse it for both discovery and the prompt reference to avoid calling
+        # ToolResolver.list_available() twice per invocation.
+        available_tools = self._available_tools()
+
         # Get recommended tools based on task analysis
-        recommended_tools = self.discover_tools_for_topic()
+        recommended_tools = self._discover_tools_for_topic(available_tools)
         recommended_agent_count = recommend_agent_count(self.topic)
         complexity = self.analyze_complexity(self.topic)
-        
-        # Build comprehensive tool list with categories
-        all_tools_by_category = []
-        for category, tools in TOOL_CATEGORIES.items():
-            all_tools_by_category.append(f"  {category}: {', '.join(tools)}")
-        tools_reference = "\n".join(all_tools_by_category)
-        
-        # Also include legacy tools for backward compatibility
-        legacy_tools = ", ".join(AVAILABLE_TOOLS)
+
+        # Prefer the real, installed tool registry so the LLM only plans with
+        # tools the user can actually run. Fall back to the static category
+        # reference when the resolver is unavailable.
+        if available_tools:
+            tools_header = "AVAILABLE TOOLS (installed)"
+            tools_reference = "\n".join(f"  - {t}" for t in available_tools)
+            legacy_tools = ", ".join(available_tools)
+        else:
+            tools_header = "AVAILABLE TOOLS BY CATEGORY"
+            all_tools_by_category = []
+            for category, tools in TOOL_CATEGORIES.items():
+                all_tools_by_category.append(f"  {category}: {', '.join(tools)}")
+            tools_reference = "\n".join(all_tools_by_category)
+            # Also include legacy tools for backward compatibility
+            legacy_tools = ", ".join(AVAILABLE_TOOLS)
         
         user_content = f"""Analyze and generate a team structure for: "{self.topic}"
 
@@ -1100,7 +1168,7 @@ Each agent should have:
 - 1 focused task with clear description and expected output
 - Appropriate tools from the recommended list
 
-AVAILABLE TOOLS BY CATEGORY:
+{tools_header}:
 {tools_reference}
 
 LEGACY TOOLS (for backward compatibility):

{praisonai-4.6.129 → praisonai-4.6.131}/praisonai/framework_adapters/praisonai_adapter.py

@@ -32,6 +32,13 @@ class PraisonAIAdapter(BaseFrameworkAdapter):
     # Native async path: arun() awaits team.astart() directly (no thread offload).
     SUPPORTS_ASYNC = True
 
+    # Native PraisonAI is the only in-tree adapter that supports workflow YAML
+    # execution and runtime features (cli_backend / runtime / models.*.runtime /
+    # providers.*.runtime_default). Capability call sites read these flags
+    # instead of hardcoding ``framework == "praisonai"``.
+    SUPPORTS_WORKFLOW = True
+    SUPPORTS_RUNTIME_FEATURES = True
+
     @property
     def name(self) -> str:
         """Return adapter name."""

praisonai-4.6.131/praisonai/framework_adapters/workflow_framework.py

@@ -0,0 +1,85 @@
+"""Workflow YAML framework field validation."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+def validate_workflow_framework(
+    framework: Optional[str],
+    *,
+    source: str = "workflow YAML",
+    registry: Any = None,
+) -> None:
+    """
+    Warn then fail when a workflow file declares a framework whose adapter does
+    not advertise workflow support.
+
+    Instead of hardcoding ``framework == "praisonai"``, ask the adapter via its
+    ``SUPPORTS_WORKFLOW`` capability flag. Third-party adapters registered via
+    the ``praisonai.framework_adapters`` entry-point group can opt in by setting
+    ``SUPPORTS_WORKFLOW = True``. The native ``praisonai`` adapter sets it, so
+    behaviour is unchanged for existing configs.
+    """
+    if not framework:
+        return
+
+    # Consult the adapter's capability flag. If resolution fails for any reason,
+    # fall back to the historical native-only behaviour.
+    try:
+        if registry is None:
+            from .registry import get_default_registry
+
+            registry = get_default_registry()
+        adapter = registry.create(framework)
+        if getattr(adapter, "SUPPORTS_WORKFLOW", False):
+            return
+    except Exception:
+        if str(framework).lower() == "praisonai":
+            return
+
+    # Discover the set of frameworks whose adapters advertise workflow support,
+    # so the guidance reflects capability flags rather than assuming praisonai
+    # is the only valid choice.
+    supported = ""
+    workflow_frameworks: list[str] = []
+    try:
+        from .registry import list_framework_choices
+    except ImportError:
+        # Only the registry module being unavailable is tolerated here; genuine
+        # discovery/initialization errors must surface rather than be masked as
+        # a simple unsupported-framework config mistake.
+        list_framework_choices = None  # type: ignore[assignment]
+
+    if list_framework_choices is not None:
+        for name in list_framework_choices(include_unavailable=True):
+            try:
+                candidate = registry.create(name) if registry is not None else None
+            except Exception:
+                candidate = None
+            if (candidate is not None and getattr(candidate, "SUPPORTS_WORKFLOW", False)) \
+                    or (candidate is None and str(name).lower() == "praisonai"):
+                workflow_frameworks.append(name)
+        if workflow_frameworks:
+            supported = (
+                f" Frameworks supporting workflow execution: "
+                f"{', '.join(sorted(set(workflow_frameworks)))}."
+            )
+
+    message = (
+        f"framework='{framework}' in {source} is not supported for workflow execution. "
+        "The workflow engine requires an adapter whose SUPPORTS_WORKFLOW flag is set "
+        "(the native 'praisonai' adapter does). "
+        "Use a non-workflow agents.yaml with a supported registered framework, "
+        f"or set framework: praisonai.{supported}"
+    )
+    logger.warning(message)
+    raise ValueError(message)
+
+
+def framework_from_config(config: Dict[str, Any]) -> str:
+    """Return normalised framework name from a parsed YAML config dict."""
+    return str(config.get("framework") or "praisonai").lower()

{praisonai-4.6.129 → praisonai-4.6.131}/praisonai/jobs/executor.py

@@ -235,8 +235,11 @@ class JobExecutor:
         await self._notify_progress(job)
         
         try:
-            # Try praisonaiagents first (preferred)
-            if framework == "praisonai":
+            # Prefer the native praisonaiagents path when the framework's adapter
+            # advertises workflow support (SUPPORTS_WORKFLOW) rather than
+            # hardcoding ``framework == "praisonai"``. Third-party adapters that
+            # opt in are routed natively; everything else uses the legacy path.
+            if self._framework_supports_native(framework):
                 result = await self._run_praisonai_agents(job, agent_file)
             else:
                 # Use legacy PraisonAI for crewai/autogen
@@ -252,6 +255,22 @@ class JobExecutor:
                 except Exception:
                     pass
     
+    @staticmethod
+    def _framework_supports_native(framework: str) -> bool:
+        """Return True if the framework's adapter advertises workflow support.
+
+        Reads the adapter's ``SUPPORTS_WORKFLOW`` capability flag instead of
+        hardcoding ``framework == "praisonai"``. Falls back to the historical
+        native-only behaviour if adapter resolution fails.
+        """
+        try:
+            from praisonai.framework_adapters.registry import get_default_registry
+
+            adapter = get_default_registry().create(framework)
+            return bool(getattr(adapter, "SUPPORTS_WORKFLOW", False))
+        except Exception:
+            return str(framework).lower() == "praisonai"
+
     async def _run_recipe(self, job: Job) -> Any:
         """Run a recipe-based job."""
         try:

praisonai-4.6.131/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "4.6.131"

{praisonai-4.6.129 → praisonai-4.6.131}/pyproject.toml

@@ -12,9 +12,9 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.132",
-    "praisonai-code>=0.0.28",
-    "praisonai-bot>=0.0.13",
+    "praisonaiagents>=1.6.134",
+    "praisonai-code>=0.0.30",
+    "praisonai-bot>=0.0.15",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",

praisonai-4.6.129/praisonai/framework_adapters/workflow_framework.py

@@ -1,51 +0,0 @@
-"""Workflow YAML framework field validation."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Dict, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def validate_workflow_framework(
-    framework: Optional[str],
-    *,
-    source: str = "workflow YAML",
-) -> None:
-    """
-    Warn then fail when a workflow file declares a non-native framework.
-
-    Multi-framework workflow dispatch is not implemented; only agents.yaml
-    via AgentsGenerator supports framework != praisonai today.
-    """
-    if not framework or str(framework).lower() == "praisonai":
-        return
-
-    supported = ""
-    try:
-        from .registry import list_framework_choices
-    except ImportError:
-        # Only the registry module being unavailable is tolerated here; genuine
-        # discovery/initialization errors must surface rather than be masked as
-        # a simple unsupported-framework config mistake.
-        list_framework_choices = None  # type: ignore[assignment]
-
-    if list_framework_choices is not None:
-        choices = [f for f in list_framework_choices(include_unavailable=True) if f != "praisonai"]
-        if choices:
-            supported = f" Available registered frameworks: {', '.join(sorted(choices))}."
-
-    message = (
-        f"framework='{framework}' in {source} is not supported for workflow execution. "
-        "Native PraisonAI Workflow engine only supports framework='praisonai'. "
-        "Use a non-workflow agents.yaml with a supported registered framework, "
-        f"or set framework: praisonai.{supported}"
-    )
-    logger.warning(message)
-    raise ValueError(message)
-
-
-def framework_from_config(config: Dict[str, Any]) -> str:
-    """Return normalised framework name from a parsed YAML config dict."""
-    return str(config.get("framework") or "praisonai").lower()

praisonai-4.6.129/praisonai/version.py

@@ -1 +0,0 @@
-__version__ = "4.6.129"