PraisonAI 4.7.12__tar.gz → 4.7.13__tar.gz

{praisonai-4.7.12 → praisonai-4.7.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.12
+Version: 4.7.13
 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,14 +11,14 @@ 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.7.10
-Requires-Dist: praisonai-code>=0.1.9
-Requires-Dist: praisonai-bot>=0.1.9
-Requires-Dist: praisonai-train>=0.1.9
-Requires-Dist: praisonai-browser>=0.1.9
-Requires-Dist: praisonai-mcp>=0.1.11
-Requires-Dist: praisonai-sandbox>=0.1.9
-Requires-Dist: praisonai-deploy>=0.1.9
+Requires-Dist: praisonaiagents>=1.7.11
+Requires-Dist: praisonai-code>=0.1.10
+Requires-Dist: praisonai-bot>=0.1.10
+Requires-Dist: praisonai-train>=0.1.10
+Requires-Dist: praisonai-browser>=0.1.10
+Requires-Dist: praisonai-mcp>=0.1.12
+Requires-Dist: praisonai-sandbox>=0.1.10
+Requires-Dist: praisonai-deploy>=0.1.10
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.7.12 → praisonai-4.7.13}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.12
+Version: 4.7.13
 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,14 +11,14 @@ 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.7.10
-Requires-Dist: praisonai-code>=0.1.9
-Requires-Dist: praisonai-bot>=0.1.9
-Requires-Dist: praisonai-train>=0.1.9
-Requires-Dist: praisonai-browser>=0.1.9
-Requires-Dist: praisonai-mcp>=0.1.11
-Requires-Dist: praisonai-sandbox>=0.1.9
-Requires-Dist: praisonai-deploy>=0.1.9
+Requires-Dist: praisonaiagents>=1.7.11
+Requires-Dist: praisonai-code>=0.1.10
+Requires-Dist: praisonai-bot>=0.1.10
+Requires-Dist: praisonai-train>=0.1.10
+Requires-Dist: praisonai-browser>=0.1.10
+Requires-Dist: praisonai-mcp>=0.1.12
+Requires-Dist: praisonai-sandbox>=0.1.10
+Requires-Dist: praisonai-deploy>=0.1.10
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.7.12 → praisonai-4.7.13}/PraisonAI.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ praisonai/capabilities/batches.py
 praisonai/capabilities/completions.py
 praisonai/capabilities/container_files.py
 praisonai/capabilities/containers.py
+praisonai/capabilities/decisions.py
 praisonai/capabilities/embeddings.py
 praisonai/capabilities/files.py
 praisonai/capabilities/fine_tuning.py

{praisonai-4.7.12 → praisonai-4.7.13}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.10
-praisonai-code>=0.1.9
-praisonai-bot>=0.1.9
-praisonai-train>=0.1.9
-praisonai-browser>=0.1.9
-praisonai-mcp>=0.1.11
-praisonai-sandbox>=0.1.9
-praisonai-deploy>=0.1.9
+praisonaiagents>=1.7.11
+praisonai-code>=0.1.10
+praisonai-bot>=0.1.10
+praisonai-train>=0.1.10
+praisonai-browser>=0.1.10
+praisonai-mcp>=0.1.12
+praisonai-sandbox>=0.1.10
+praisonai-deploy>=0.1.10
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.7.12 → praisonai-4.7.13}/praisonai/acp/session.py

@@ -6,6 +6,9 @@ Handles session creation, persistence, and resume functionality.
 
 import json
 import logging
+import os
+import re
+import tempfile
 import time
 import uuid
 from dataclasses import dataclass, field
@@ -14,6 +17,23 @@ from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger(__name__)
 
+# Matches the ids minted by ``ACPSession.create`` (``sess_`` + 16 hex chars).
+# Allowing up to 32 hex chars keeps forward-compat if the id width grows.
+_SESSION_ID_RE = re.compile(r"^sess_[0-9a-f]{1,32}$")
+
+
+def _validate_session_id(session_id: str) -> str:
+    """Reject anything that is not a server-minted session id.
+
+    ``session_id`` arrives over JSON-RPC from an external peer and is
+    interpolated into a filesystem path, so an unvalidated value like
+    ``"../../tmp/secret"`` would let the peer read or delete arbitrary
+    ``*.json`` files. Only ids matching the ``create()`` format are allowed.
+    """
+    if not isinstance(session_id, str) or not _SESSION_ID_RE.match(session_id):
+        raise ValueError(f"invalid session_id: {session_id!r}")
+    return session_id
+
 
 @dataclass
 class ACPSession:
@@ -124,23 +144,46 @@ class SessionStore:
         self._last_session_file = self.storage_dir / ".last_session"
     
     def _session_path(self, session_id: str) -> Path:
-        """Get path for session file."""
-        return self.storage_dir / f"{session_id}.json"
-    
+        """Get path for session file (validated against traversal)."""
+        _validate_session_id(session_id)
+        # ``resolve`` anchors the path so a future id-format change can't
+        # silently re-open the traversal hole.
+        return (self.storage_dir / f"{session_id}.json").resolve()
+
+    @staticmethod
+    def _atomic_write(path: Path, text: str) -> None:
+        """Write ``text`` to ``path`` atomically via a temp file + os.replace.
+
+        A crash or Ctrl-C mid-write can never leave the target empty or
+        half-written — the old content survives until the rename succeeds.
+        """
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(prefix=".sess-", suffix=".tmp", dir=str(path.parent))
+        try:
+            with os.fdopen(fd, "w") as f:
+                f.write(text)
+                f.flush()
+                os.fsync(f.fileno())
+            os.replace(tmp, path)
+        except BaseException:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+
     def save(self, session: ACPSession) -> None:
-        """Save session to disk."""
+        """Save session to disk atomically."""
         try:
             path = self._session_path(session.session_id)
-            with open(path, "w") as f:
-                json.dump(session.to_dict(), f, indent=2)
-            
-            # Update last session pointer
-            with open(self._last_session_file, "w") as f:
-                f.write(session.session_id)
-            
+            self._atomic_write(path, json.dumps(session.to_dict(), indent=2))
+
+            # Update last session pointer ONLY after the payload is durable.
+            self._atomic_write(self._last_session_file, session.session_id)
+
             logger.debug(f"Saved session {session.session_id}")
         except Exception as e:
-            logger.error(f"Failed to save session: {e}")
+            logger.error(f"Failed to save session {session.session_id}: {e}")
     
     def load(self, session_id: str) -> Optional[ACPSession]:
         """Load session from disk."""

{praisonai-4.7.12 → praisonai-4.7.13}/praisonai/agents_generator.py

@@ -373,7 +373,7 @@ def _make_timeout_proxy(inner, wrapped_run=None, wrapped__run=None):
     return proxy
 
 
-def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked=None, owner_key=None):
+def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked=None, owner_key=None, native_delegates_to_core=False):
     """Enforce a per-call timeout on a tool, sync or async.
 
     For async tools the underlying task is cancelled on timeout. For sync tools
@@ -387,10 +387,33 @@ def _wrap_with_timeout(tool, timeout_seconds: float, executor_factory, on_leaked
     On timeout the wrapper raises :class:`ToolTimeoutError` rather than returning
     a JSON string, so a tool's declared return-type contract is never silently
     downgraded; the framework adapter decides how to surface the timeout.
+
+    ``native_delegates_to_core``: when True, a *plain native callable* (not a
+    framework tool object) is returned unwrapped so core's own per-tool timeout
+    enforcement (``praisonaiagents`` ``agent/tool_execution.py`` /
+    ``tools/call_executor.py``, configured via the agent's ``tool_config``
+    timeout) owns it — avoiding a second, duplicated abandon-on-timeout thread
+    pool for tools that already flow through core (#5650). Framework tool
+    objects (CrewAI/AutoGen/LangChain ``BaseTool``) never reach core's executor,
+    so they are *always* wrapped here to preserve their ``args_schema``.
     """
     if timeout_seconds is None or timeout_seconds <= 0:
         return tool
 
+    # praisonai-native path: a plain callable already flows through core's tool
+    # executor, which enforces the resolved per-tool timeout. Returning it
+    # unwrapped lets core own the abandon-on-expiry semantics instead of the
+    # wrapper standing up a second thread pool with the same behaviour. Only
+    # framework tool objects (which bypass core) still need wrapper wrapping, so
+    # they fall through to the logic below.
+    if (
+        native_delegates_to_core
+        and callable(tool)
+        and not isinstance(tool, type)
+        and not _looks_like_framework_tool(tool)
+    ):
+        return tool
+
     import asyncio
     import concurrent.futures
     import functools
@@ -775,14 +798,31 @@ class AgentsGenerator:
         with self._tool_timeout_executor_lock:
             self._leaked_workers += 1
 
-    def _wrap_tool_with_timeout(self, tool, timeout_seconds):
-        """Wrap a tool with this generator's instance-owned timeout executor."""
+    def _wrap_tool_with_timeout(self, tool, timeout_seconds, native_delegates_to_core=None):
+        """Wrap a tool with this generator's instance-owned timeout executor.
+
+        On the praisonai-native framework the resolved per-tool timeout is
+        enforced by core (``praisonaiagents`` ``agent/tool_execution.py``, wired
+        via the agent's ``tool_config`` timeout), so a *native* callable is left
+        unwrapped here instead of being bound to a second wrapper-owned thread
+        pool with the same abandon-on-expiry semantics (#5650). Framework tool
+        objects (CrewAI/AutoGen/LangChain ``BaseTool``) bypass core, so they are
+        still wrapped.
+
+        ``native_delegates_to_core``: callers that already know the resolved
+        framework (the per-run wrap/resolver closures) pass it explicitly;
+        otherwise it is inferred from ``self.framework`` (resolved to the chosen
+        adapter name by the time an adapter invokes a wrap closure at run time).
+        """
+        if native_delegates_to_core is None:
+            native_delegates_to_core = (getattr(self, "framework", None) or "") == "praisonai"
         return _wrap_with_timeout(
             tool,
             timeout_seconds,
             self._get_tool_timeout_executor,
             on_leaked=self._note_leaked_worker,
             owner_key=self._timeout_owner_key,
+            native_delegates_to_core=native_delegates_to_core,
         )
 
     def close(self):
@@ -1080,11 +1120,35 @@ class AgentsGenerator:
         # that when the *same* generator instance is reused with a different
         # timeout layout, a stale closure from a previous run can never leak into
         # the adapters and apply the wrong budget to the current run.
+        # Resolve the chosen framework now (the same registry resolution the
+        # run prep uses) so native-vs-framework tool handling is decided BEFORE
+        # the uniform wrap is applied eagerly below — ``self.framework`` is not
+        # yet updated to the resolved adapter name at this point in the run.
+        _requested_framework = getattr(self, "framework", None) or config.get('framework')
+        registry = getattr(self, "_adapter_registry", None)
+        try:
+            resolved_framework = (
+                registry.resolve_or_default(_requested_framework)
+                if registry is not None else _requested_framework
+            )
+        except Exception:
+            resolved_framework = _requested_framework
+        native = resolved_framework == "praisonai"
+
         uniform = self._resolve_uniform_tool_timeout(config)
         wrap = None
         resolver = None
         if uniform and uniform > 0:
-            wrap = lambda t, _sec=uniform: self._wrap_tool_with_timeout(t, _sec)
+            # On the native framework a *plain callable* is left unwrapped so
+            # core enforces the budget (#5650) — the raw value is exposed below
+            # so the native adapter configures each agent's tool_config timeout.
+            # Framework tool *objects* are still wrapped here regardless, so
+            # their args_schema survives for the LLM. ``native`` is passed
+            # explicitly because ``self.framework`` is not yet resolved here.
+            wrap = (
+                lambda t, _sec=uniform, _n=native:
+                self._wrap_tool_with_timeout(t, _sec, native_delegates_to_core=_n)
+            )
             tools_dict = {name: wrap(tool) for name, tool in tools_dict.items()}
         else:
             # No single uniform timeout. If any agent declared a per-agent
@@ -1105,9 +1169,21 @@ class AgentsGenerator:
         # so adapters still read them via the same keys. Both are written every
         # time so the inactive path is cleared rather than left holding a prior
         # closure.
+        # On the native framework, plain callables are no longer wrapped by the
+        # wrapper's own executor (above) — core enforces the timeout instead
+        # (#5650). Expose the resolved per-agent timeout (float seconds) so the
+        # native adapter can configure each core Agent's ``tool_config`` timeout.
+        # ``None`` for non-native frameworks, which keep wrapper-side wrapping.
+        native_tool_timeout_resolver = None
+        if native:
+            native_tool_timeout_resolver = (
+                lambda agent_key, _cfg=config: self.resolve_agent_tool_timeout(agent_key, _cfg)
+            )
+
         self._run_ctx = {
             "_tool_timeout_wrap": wrap,
             "_agent_tool_wrap_resolver": resolver,
+            "_native_tool_timeout_resolver": native_tool_timeout_resolver,
         }
         return tools_dict
 

{praisonai-4.7.12 → praisonai-4.7.13}/praisonai/capabilities/__init__.py

@@ -68,6 +68,13 @@ __all__ = [
     'aembed',
     'embedding',  # Alias for embed
     'aembedding',  # Alias for aembed
+    # System One / Jev decisions (Ollama /v1/systemone)
+    'system_one',
+    'asystem_one',
+    'choice_question',
+    'noul_question',
+    'score_question',
+    'is_decision_model',
     # Rerank
     'rerank',
     'arerank',
@@ -155,6 +162,7 @@ __all__ = [
     'BatchResult',
     'VectorStoreResult',
     'EmbeddingResult',
+    'SystemOneResult',
     'RerankResult',
     'ModerationResult',
     'OCRResult',
@@ -197,6 +205,10 @@ _ATTR_TO_MODULE = {
     # Embeddings
     'embed': 'embeddings', 'aembed': 'embeddings', 'EmbeddingResult': 'embeddings',
     'embedding': 'embeddings', 'aembedding': 'embeddings',  # Aliases
+    # System One decisions
+    'system_one': 'decisions', 'asystem_one': 'decisions',
+    'choice_question': 'decisions', 'noul_question': 'decisions', 'score_question': 'decisions',
+    'is_decision_model': 'decisions', 'SystemOneResult': 'decisions',
     # Rerank
     'rerank': 'rerank_module', 'arerank': 'rerank_module', 'RerankResult': 'rerank_module',
     # Moderations

praisonai-4.7.13/praisonai/capabilities/decisions.py

@@ -0,0 +1,31 @@
+"""
+System One / Jev typed decision capabilities (Ollama ``/v1/systemone``).
+
+Thin re-export of ``praisonaiagents.decisions`` for ``praisonai.capabilities`` parity.
+"""
+
+from praisonaiagents.decisions import (
+    KNOWN_DECISION_MODELS,
+    SystemOneResult,
+    asystem_one,
+    choice_question,
+    is_decision_model,
+    noul_question,
+    resolve_system_one_base_url,
+    score_question,
+    system_one,
+    system_one_via_typesafe_sdk,
+)
+
+__all__ = [
+    "KNOWN_DECISION_MODELS",
+    "SystemOneResult",
+    "asystem_one",
+    "choice_question",
+    "is_decision_model",
+    "noul_question",
+    "resolve_system_one_base_url",
+    "score_question",
+    "system_one",
+    "system_one_via_typesafe_sdk",
+]

{praisonai-4.7.12 → praisonai-4.7.13}/praisonai/cli/commands/schedule.py

@@ -372,7 +372,7 @@ def _daemon_states_payload() -> list:
                 "source": "daemon",
                 "name": s.get("name", "unknown"),
                 "pid": pid,
-                "status": "running" if state_manager.is_process_alive(pid) else "stopped",
+                "status": "running" if state_manager.is_process_alive(pid, s.get("start_time")) else "stopped",
                 "interval": s.get("interval", "unknown"),
                 "task": s.get("task", ""),
             })

{praisonai-4.7.12 → praisonai-4.7.13}/praisonai/cli/features/agent_scheduler.py

@@ -74,7 +74,18 @@ class AgentSchedulerHandler:
         
         # Parse arguments
         name = unknown_args[0]
-        
+
+        # Validate the name BEFORE launching any daemon: save_state rejects an
+        # unsafe name, and launching first would orphan a running daemon with no
+        # state file the CLI could use to stop it.
+        from praisonai.scheduler.state_manager import _validate_name
+        try:
+            _validate_name(name)
+        except ValueError:
+            print(f"❌ Error: Invalid scheduler name {name!r}")
+            print("   Use letters, digits, '_', '-', '.' (max 128 chars, no '..').")
+            return 1
+
         # Check for --recipe flag in unknown_args
         recipe_name = None
         task = None
@@ -96,9 +107,13 @@ class AgentSchedulerHandler:
         max_cost = getattr(args, 'max_cost', None)
         deliver = getattr(args, 'schedule_deliver', None) or ''
         
-        # Check if name already exists
+        # Check if name already exists. Use is_process_alive with the recorded
+        # start_time (not a PID-only probe) so a stale state whose PID was reused
+        # by an unrelated process does not falsely block a fresh start.
         existing = state_manager.load_state(name)
-        if existing and daemon_manager.get_status(existing.get('pid', 0))['is_alive']:
+        if existing and state_manager.is_process_alive(
+            existing.get('pid', 0), existing.get('start_time')
+        ):
             print(f"❌ Error: Scheduler '{name}' is already running (PID: {existing['pid']})")
             print(f"   Use 'praisonai schedule stop {name}' to stop it first")
             return 1
@@ -177,7 +192,7 @@ class AgentSchedulerHandler:
         for state in states:
             name = state.get('name', 'unknown')[:20]
             pid = state.get('pid', 0)
-            status = "running" if state_manager.is_process_alive(pid) else "stopped"
+            status = "running" if state_manager.is_process_alive(pid, state.get('start_time')) else "stopped"
             interval = state.get('interval', 'unknown')[:12]
             task = state.get('task', '')[:40]
             
@@ -261,7 +276,7 @@ class AgentSchedulerHandler:
             pid = state['pid']
             
             try:
-                if daemon_manager.stop_daemon(pid):
+                if daemon_manager.stop_daemon(pid, expected_start_time=state.get('start_time')):
                     state_manager.delete_state(name)
                     print(f"✅ Stopped '{name}' (PID: {pid})")
                     stopped += 1
@@ -298,7 +313,7 @@ class AgentSchedulerHandler:
         
         print(f"🛑 Stopping scheduler '{name}' (PID: {pid})...")
         
-        success = daemon_manager.stop_daemon(pid)
+        success = daemon_manager.stop_daemon(pid, expected_start_time=state.get('start_time'))
         
         if success:
             state['status'] = 'stopped'
@@ -365,8 +380,9 @@ class AgentSchedulerHandler:
         
         # Stop if running
         pid = state.get('pid')
-        if pid and state_manager.is_process_alive(pid):
-            daemon_manager.stop_daemon(pid)
+        start_time = state.get('start_time')
+        if pid and state_manager.is_process_alive(pid, start_time):
+            daemon_manager.stop_daemon(pid, expected_start_time=start_time)
             time.sleep(1)
         
         # Start again
@@ -384,6 +400,7 @@ class AgentSchedulerHandler:
         state['pid'] = new_pid
         state['status'] = 'running'
         state['started_at'] = datetime.now().isoformat()
+        state.pop('start_time', None)  # let save_state record the new process's identity
         state_manager.save_state(name, state)
         
         print(f"✅ Scheduler '{name}' restarted (PID: {new_pid})")
@@ -426,7 +443,7 @@ class AgentSchedulerHandler:
         
         # Get process status
         pid = state.get('pid', 0)
-        is_alive = state_manager.is_process_alive(pid)
+        is_alive = state_manager.is_process_alive(pid, state.get('start_time'))
         status = "🟢 running" if is_alive else "🔴 stopped"
         
         # Calculate uptime

{praisonai-4.7.12 → praisonai-4.7.13}/praisonai/framework_adapters/praisonai_adapter.py

@@ -596,7 +596,37 @@ class PraisonAIAdapter(BaseFrameworkAdapter):
             # Add approval config if present
             if agent_approval:
                 agent_kwargs['approval'] = agent_approval
-            
+
+            # Forward the resolved per-agent tool_timeout to core so native
+            # tools are enforced by core's own per-tool timeout (#5650) instead
+            # of a duplicate wrapper-side executor. The generator exposes the
+            # resolved budget only on the native framework; framework tool
+            # objects keep wrapper-side wrapping. A user-supplied tool_config in
+            # YAML (details['llm'] etc.) is not overridden here — this only
+            # fills the timeout the wrapper would otherwise have enforced.
+            native_timeout_resolver = (cli_config or {}).get(
+                "_native_tool_timeout_resolver"
+            )
+            if callable(native_timeout_resolver) and 'tool_config' not in agent_kwargs:
+                budget = native_timeout_resolver(role)
+                if isinstance(budget, (int, float)) and not isinstance(budget, bool) and budget > 0:
+                    try:
+                        from praisonaiagents.config.feature_configs import ToolConfig
+                        # Preserve the resolved budget as-is (float seconds).
+                        # Core consumes ToolConfig.timeout directly as seconds in
+                        # both the sync (future.result(timeout=...)) and async
+                        # (asyncio.wait_for(timeout=...)) paths, so fractional
+                        # budgets survive. Rounding to int would collapse a
+                        # subsecond budget (e.g. 0.4 -> 0), and core treats a
+                        # non-positive timeout as "no timeout" — silently dropping
+                        # enforcement for native callables that are now unwrapped.
+                        agent_kwargs['tool_config'] = ToolConfig(timeout=budget)
+                    except Exception as _tc_err:
+                        logger.warning(
+                            "Could not set core tool_config timeout for agent %r: %s",
+                            role_filled, _tc_err,
+                        )
+
             agent = PraisonAgent(**agent_kwargs)
             
             if agent_callback: