PraisonAI 4.6.144__tar.gz → 4.6.146__tar.gz

{praisonai-4.6.144 → praisonai-4.6.146}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.144
+Version: 4.6.146
 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.147
-Requires-Dist: praisonai-code>=0.0.43
-Requires-Dist: praisonai-bot>=0.0.28
+Requires-Dist: praisonaiagents>=1.6.149
+Requires-Dist: praisonai-code>=0.0.45
+Requires-Dist: praisonai-bot>=0.0.30
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.144 → praisonai-4.6.146}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.144
+Version: 4.6.146
 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.147
-Requires-Dist: praisonai-code>=0.0.43
-Requires-Dist: praisonai-bot>=0.0.28
+Requires-Dist: praisonaiagents>=1.6.149
+Requires-Dist: praisonai-code>=0.0.45
+Requires-Dist: praisonai-bot>=0.0.30
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.144 → praisonai-4.6.146}/PraisonAI.egg-info/SOURCES.txt

@@ -525,6 +525,7 @@ praisonai/sandbox/ssh.py
 praisonai/sandbox/subprocess.py
 praisonai/scheduler/__init__.py
 praisonai/scheduler/_base_scheduler.py
+praisonai/scheduler/_delivery.py
 praisonai/scheduler/_dispatch.py
 praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/async_agent_scheduler.py

{praisonai-4.6.144 → praisonai-4.6.146}/PraisonAI.egg-info/requires.txt

@@ -1,9 +1,9 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.147
-praisonai-code>=0.0.43
-praisonai-bot>=0.0.28
+praisonaiagents>=1.6.149
+praisonai-code>=0.0.45
+praisonai-bot>=0.0.30
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.144 → praisonai-4.6.146}/praisonai/_entrypoint.py

@@ -14,14 +14,14 @@ def _build_config_list() -> list[dict[str, Any]]:
     return build_config_list()
 
 
-def run(agent_file: str,
-        framework: str | None = None,
-        *,
-        tools: list | None = None,
-        agent_yaml: str | None = None,
-        cli_config: dict | None = None) -> str:
-    """One-line Python entry point. Equivalent to `praisonai <agent_file>`."""
-    from .agents_generator import AgentsGenerator
+def _resolve_run_inputs(framework: str | None) -> tuple[str, list[dict[str, Any]]]:
+    """Single source of truth for wrapper entry-point resolution.
+
+    Resolves the framework (default selection or explicit validation) and builds
+    the LLM config list. This performs synchronous work — including credential /
+    config file I/O via ``_build_config_list`` — so async callers must invoke it
+    off the event loop (see ``arun``).
+    """
     from .framework_adapters.registry import get_default_registry
 
     if framework is None:
@@ -33,10 +33,24 @@ def run(agent_file: str,
         from .framework_adapters.validators import assert_framework_available
         assert_framework_available(framework)
 
+    return framework, _build_config_list()
+
+
+def run(agent_file: str,
+        framework: str | None = None,
+        *,
+        tools: list | None = None,
+        agent_yaml: str | None = None,
+        cli_config: dict | None = None) -> str:
+    """One-line Python entry point. Equivalent to `praisonai <agent_file>`."""
+    from .agents_generator import AgentsGenerator
+
+    framework, config_list = _resolve_run_inputs(framework)
+
     gen = AgentsGenerator(
         agent_file=agent_file,
         framework=framework,
-        config_list=_build_config_list(),
+        config_list=config_list,
         tools=tools,
         agent_yaml=agent_yaml,
         cli_config=cli_config,
@@ -51,22 +65,19 @@ async def arun(agent_file: str,
                agent_yaml: str | None = None,
                cli_config: dict | None = None) -> str:
     """Async equivalent of `run()` using native async framework adapters."""
+    import asyncio
+
     from .agents_generator import AgentsGenerator
-    from .framework_adapters.registry import get_default_registry
 
-    if framework is None:
-        # Single source of truth for default selection: the registry, which
-        # honours entry-point plugins as well as the built-in priority order.
-        framework = get_default_registry().pick_default()
-    else:
-        # Validate explicit framework like CLI does
-        from .framework_adapters.validators import assert_framework_available
-        assert_framework_available(framework)
+    # Resolve framework + build config_list off the caller's event loop so the
+    # synchronous credential/config-file I/O does not block it. This is the
+    # reason arun exists: a FastAPI handler awaiting arun must not stall the loop.
+    framework, config_list = await asyncio.to_thread(_resolve_run_inputs, framework)
 
     gen = AgentsGenerator(
         agent_file=agent_file,
         framework=framework,
-        config_list=_build_config_list(),
+        config_list=config_list,
         tools=tools,
         agent_yaml=agent_yaml,
         cli_config=cli_config,

{praisonai-4.6.144 → praisonai-4.6.146}/praisonai/agents_generator.py

@@ -182,6 +182,26 @@ def _resolve_tool_timeout_workers():
     return workers
 
 
+def _looks_like_framework_tool(tool) -> bool:
+    """Whether ``tool`` is a framework tool object carrying a typed schema.
+
+    CrewAI / LangChain ``BaseTool`` instances and praisonai ``@tool`` objects
+    expose ``name``/``description`` plus an ``args_schema`` (or a dedicated
+    ``_run``/``run`` execution method). Such metadata is what the downstream
+    framework uses to advertise the tool to the LLM, so it must survive
+    timeout-wrapping. A bare function or a plain class returns False.
+    """
+    if isinstance(tool, type):
+        return False
+    has_schema = any(
+        hasattr(tool, attr) for attr in ("args_schema", "name", "description")
+    )
+    has_exec_method = any(
+        callable(getattr(tool, m, None)) for m in ("_run", "run")
+    )
+    return has_schema and has_exec_method
+
+
 def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked=None):
     """Enforce a per-call timeout on a tool, sync or async.
 
@@ -197,56 +217,88 @@ def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked
     a JSON string, so a tool's declared return-type contract is never silently
     downgraded; the framework adapter decides how to surface the timeout.
     """
-    if timeout_seconds is None or timeout_seconds <= 0 or not callable(tool):
+    if timeout_seconds is None or timeout_seconds <= 0:
         return tool
-    
+
     import asyncio
     import concurrent.futures
     import functools
     import inspect
-    
-    if inspect.iscoroutinefunction(tool):
-        @functools.wraps(tool)
-        async def _async_wrapped(*args, **kwargs):
+
+    def _wrap_callable(fn):
+        """Return a timeout-enforcing wrapper around a bare callable."""
+        if not callable(fn):
+            return fn
+
+        if inspect.iscoroutinefunction(fn):
+            @functools.wraps(fn)
+            async def _async_wrapped(*args, **kwargs):
+                try:
+                    return await asyncio.wait_for(fn(*args, **kwargs), timeout=timeout_seconds)
+                except asyncio.TimeoutError:
+                    # asyncio.wait_for cancels the underlying task, so no work leaks.
+                    raise ToolTimeoutError(
+                        tool_name=getattr(fn, "__name__", repr(fn)),
+                        timeout_seconds=timeout_seconds,
+                        background_work_may_continue=False,
+                    )
+            return _async_wrapped
+
+        @functools.wraps(fn)
+        def _sync_wrapped(*args, **kwargs):
+            executor = executor_factory()
+            future = executor.submit(fn, *args, **kwargs)
             try:
-                return await asyncio.wait_for(tool(*args, **kwargs), timeout=timeout_seconds)
-            except asyncio.TimeoutError:
-                # asyncio.wait_for cancels the underlying task, so no work leaks.
+                return future.result(timeout=timeout_seconds)
+            except concurrent.futures.TimeoutError:
+                # Best-effort cancel; only effective if the future has not started.
+                # A started sync call cannot be interrupted, so warn operators that
+                # the worker may keep running (and its side effects may still occur).
+                cancelled = future.cancel()
+                if not cancelled and on_leaked is not None:
+                    # The worker is stuck and OS-owned; let the generator recycle
+                    # the pool so new submissions are not permanently queued behind
+                    # leaked threads.
+                    on_leaked()
+                logger.warning(
+                    "Tool %r exceeded %.1fs (cancel=%s); worker may continue "
+                    "executing in the background.",
+                    getattr(fn, "__name__", repr(fn)),
+                    timeout_seconds, cancelled,
+                )
                 raise ToolTimeoutError(
-                    tool_name=getattr(tool, "__name__", repr(tool)),
+                    tool_name=getattr(fn, "__name__", repr(fn)),
                     timeout_seconds=timeout_seconds,
-                    background_work_may_continue=False,
+                    background_work_may_continue=not cancelled,
                 )
-        return _async_wrapped
-
-    @functools.wraps(tool)
-    def _sync_wrapped(*args, **kwargs):
-        executor = executor_factory()
-        future = executor.submit(tool, *args, **kwargs)
-        try:
-            return future.result(timeout=timeout_seconds)
-        except concurrent.futures.TimeoutError:
-            # Best-effort cancel; only effective if the future has not started.
-            # A started sync call cannot be interrupted, so warn operators that
-            # the worker may keep running (and its side effects may still occur).
-            cancelled = future.cancel()
-            if not cancelled and on_leaked is not None:
-                # The worker is stuck and OS-owned; let the generator recycle
-                # the pool so new submissions are not permanently queued behind
-                # leaked threads.
-                on_leaked()
-            logger.warning(
-                "Tool %r exceeded %.1fs (cancel=%s); worker may continue "
-                "executing in the background.",
-                getattr(tool, "__name__", repr(tool)),
-                timeout_seconds, cancelled,
-            )
-            raise ToolTimeoutError(
-                tool_name=getattr(tool, "__name__", repr(tool)),
-                timeout_seconds=timeout_seconds,
-                background_work_may_continue=not cancelled,
-            )
-    return _sync_wrapped
+        return _sync_wrapped
+
+    # Framework tool object (CrewAI/LangChain BaseTool, praisonai @tool). These
+    # carry name / description / args_schema that the downstream framework needs
+    # to advertise the tool to the LLM. Replacing them with a bare function
+    # (functools.wraps copies only __name__/__doc__ etc., NOT args_schema) makes
+    # the framework infer a (*args, **kwargs) schema and the LLM emits malformed
+    # tool_calls. Instead, wrap only the execution method IN PLACE so the object
+    # — and its schema — survive.
+    if not callable(tool) or _looks_like_framework_tool(tool):
+        for method_name in ("_run", "run"):
+            method = getattr(tool, method_name, None)
+            if callable(method):
+                wrapped = _wrap_callable(method)
+                if wrapped is method:
+                    continue
+                try:
+                    object.__setattr__(tool, method_name, wrapped)  # bypass pydantic frozen
+                    return tool
+                except (AttributeError, TypeError):
+                    break  # fall through to callable wrapping below
+        # No patchable execution method or non-callable object; return as-is so
+        # we never silently drop a tool object we couldn't safely wrap.
+        if not callable(tool):
+            return tool
+
+    # Plain callable — safe to wrap as a function.
+    return _wrap_callable(tool)
 
 
 def noop(*args, **kwargs):

{praisonai-4.6.144 → praisonai-4.6.146}/praisonai/cli/features/agent_scheduler.py

@@ -94,6 +94,7 @@ class AgentSchedulerHandler:
         max_retries = getattr(args, 'schedule_max_retries', None) or 3
         timeout = getattr(args, 'timeout', None)
         max_cost = getattr(args, 'max_cost', None)
+        deliver = getattr(args, 'schedule_deliver', None) or ''
         
         # Check if name already exists
         existing = state_manager.load_state(name)
@@ -121,7 +122,8 @@ class AgentSchedulerHandler:
             interval=interval,
             max_cost=max_cost,
             timeout=timeout,
-            max_retries=max_retries
+            max_retries=max_retries,
+            deliver=deliver
         )
         
         # Save state
@@ -134,6 +136,7 @@ class AgentSchedulerHandler:
             "timeout": timeout,
             "max_cost": max_cost,
             "max_retries": max_retries,
+            "deliver": deliver,
             "status": "running",
             "started_at": datetime.now().isoformat(),
             "executions": 0,
@@ -370,10 +373,12 @@ class AgentSchedulerHandler:
         new_pid = daemon_manager.start_scheduler_daemon(
             name=name,
             task=state['task'],
+            recipe_name=state.get('recipe_name'),
             interval=state['interval'],
             max_cost=state.get('max_cost'),
             timeout=state.get('timeout'),
-            max_retries=state.get('max_retries', 3)
+            max_retries=state.get('max_retries', 3),
+            deliver=state.get('deliver', '')
         )
         
         state['pid'] = new_pid
@@ -557,6 +562,7 @@ class AgentSchedulerHandler:
         max_retries_override = getattr(args, 'schedule_max_retries', None) or 3
         timeout_override = getattr(args, 'timeout', None)
         max_cost_override = getattr(args, 'max_cost', None)
+        deliver_override = getattr(args, 'schedule_deliver', None) or ''
         verbose = getattr(args, 'verbose', False)
         
         # Set up logging - only show logs if verbose
@@ -630,9 +636,14 @@ class AgentSchedulerHandler:
                     agent=agent,
                     task=task,
                     timeout=timeout_override,
-                    max_cost=max_cost_override
+                    max_cost=max_cost_override,
+                    deliver=deliver_override
                 )
-            
+
+            # A CLI --deliver overrides any target resolved from YAML/recipe.
+            if deliver_override:
+                scheduler.deliver = deliver_override
+
             # Get configuration
             interval = interval_override
             max_retries = max_retries_override
@@ -754,6 +765,16 @@ schedule:
             help='Override maximum retry attempts (default: from YAML or 3)'
         )
         
+        schedule_parser.add_argument(
+            '--deliver', '-d',
+            dest='schedule_deliver',
+            type=str,
+            help=(
+                "Deliver each result to a chat target "
+                "(e.g. 'telegram:123456', 'telegram', 'telegram:123:thread')"
+            ),
+        )
+
         schedule_parser.add_argument(
             '--verbose', '-v',
             action='store_true',

{praisonai-4.6.144 → praisonai-4.6.146}/praisonai/cli/interactive/core.py

@@ -329,6 +329,10 @@ class InteractiveCore:
                 else:
                     agent_config["autonomy"] = True
             
+            session_registry = self._build_subtree_hook_registry(project_context)
+            if session_registry is not None:
+                agent_config["hooks"] = session_registry
+
             self._agent = Agent(**agent_config)
         
         agent = self._agent
@@ -408,6 +412,45 @@ class InteractiveCore:
         self._project_context = context
         return context
 
+    def _build_subtree_hook_registry(self, already_loaded: str):
+        """Build a session-scoped ``HookRegistry`` for subtree instruction rules.
+
+        Complements the up-front (nearest-wins walk-up) project context by
+        lazily attaching a subdirectory's instruction file the first time the
+        agent reads/edits a file under it. The hook is registered on a *fresh*
+        registry (never the global default) so its per-session dedup state stays
+        isolated and cannot leak into other agents/sessions.
+
+        Returns the registry to pass as ``Agent(hooks=...)``, or ``None`` when
+        ``--no-context`` is set or the wrapper helper is unavailable (the caller
+        then constructs the agent without a custom registry).
+        """
+        if getattr(self.config, "no_context", False):
+            return None
+        try:
+            from praisonai.integration.context_files import (
+                build_subtree_context_hook,
+                file_tool_matcher,
+            )
+            from praisonaiagents.hooks import HookEvent, HookRegistry
+        except ImportError:
+            return None
+
+        try:
+            budget = getattr(self.config, "context_token_budget", 0) or 0
+            hook = build_subtree_context_hook(already_loaded, max_chars=budget)
+            registry = HookRegistry()
+            registry.register_function(
+                event=HookEvent.AFTER_TOOL,
+                func=hook,
+                matcher=file_tool_matcher(),
+                name="subtree_instruction_injection",
+            )
+            return registry
+        except Exception as e:  # pragma: no cover - defensive wiring
+            logger.warning(f"Could not build subtree context hook: {e}")
+            return None
+
     # ========== Tool Management ==========
     
     def get_tools(self) -> List: