PraisonAI 4.6.142__tar.gz → 4.6.143__tar.gz

{praisonai-4.6.142 → praisonai-4.6.143}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.142
+Version: 4.6.143
 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.145
-Requires-Dist: praisonai-code>=0.0.41
-Requires-Dist: praisonai-bot>=0.0.26
+Requires-Dist: praisonaiagents>=1.6.146
+Requires-Dist: praisonai-code>=0.0.42
+Requires-Dist: praisonai-bot>=0.0.27
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.142 → praisonai-4.6.143}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.142
+Version: 4.6.143
 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.145
-Requires-Dist: praisonai-code>=0.0.41
-Requires-Dist: praisonai-bot>=0.0.26
+Requires-Dist: praisonaiagents>=1.6.146
+Requires-Dist: praisonai-code>=0.0.42
+Requires-Dist: praisonai-bot>=0.0.27
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.142 → praisonai-4.6.143}/PraisonAI.egg-info/SOURCES.txt

@@ -14,7 +14,6 @@ praisonai/_bootstrap.py
 praisonai/_entrypoint.py
 praisonai/_framework_availability.py
 praisonai/_lazy_cache.py
-praisonai/_lockmap.py
 praisonai/_logging.py
 praisonai/_registry.py
 praisonai/_safe_loader.py

{praisonai-4.6.142 → praisonai-4.6.143}/PraisonAI.egg-info/requires.txt

@@ -1,9 +1,9 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.145
-praisonai-code>=0.0.41
-praisonai-bot>=0.0.26
+praisonaiagents>=1.6.146
+praisonai-code>=0.0.42
+praisonai-bot>=0.0.27
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.142 → praisonai-4.6.143}/praisonai/auto.py

@@ -10,7 +10,7 @@ This module uses FULL LAZY LOADING for all heavy dependencies:
 
 This ensures minimal import-time overhead.
 """
-from typing import Any, Dict, List, Optional, Type, TypeVar
+from typing import Any, Awaitable, Dict, List, Optional, Type, TypeVar
 import os
 import json
 import asyncio
@@ -620,7 +620,61 @@ class BaseAutoGenerator:
             ImportError: If neither litellm nor openai is installed
         """
         return await self._completion_impl(response_model, messages, is_async=True, **kwargs)
-    
+
+    async def _structured_completion_async(
+        self, response_model: Type[T], messages: List[Dict], *, is_async: bool, **kwargs
+    ) -> T:
+        """Await the structured-completion ladder with an explicit provider path.
+
+        Lets a single generation coroutine be driven either through the async
+        provider clients (``is_async=True``, from ``agenerate()``) or the sync
+        provider clients (``is_async=False``, from the sync ``generate()``
+        bridge). This preserves the historical behavior where a sync
+        ``generate()`` call used the blocking sync client/network stack, while
+        still routing both entry points through one shared body.
+        """
+        return await self._completion_impl(
+            response_model, messages, is_async=is_async, **kwargs
+        )
+
+    def _run_coro_sync(self, coro: Awaitable[T]) -> T:
+        """Drive an async coroutine to completion from a sync caller.
+
+        Single source of truth so the sync ``generate()`` twins can delegate to
+        their ``agenerate()`` implementation instead of duplicating the body.
+
+        Mirrors the running-loop handling in ``_structured_completion``: when no
+        event loop is running we use the shared async bridge; when a loop is
+        already running (FastAPI handler, Jupyter, async test) ``run_sync``
+        would raise, so we drive the coroutine on a dedicated worker thread with
+        its own loop instead.
+        """
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            running_loop = False
+        else:
+            running_loop = True
+
+        if not running_loop:
+            return run_sync(coro)
+
+        result: List[Any] = []
+        error: List[BaseException] = []
+
+        def _runner() -> None:
+            try:
+                result.append(asyncio.run(coro))
+            except BaseException as e:  # noqa: BLE001 - re-raised on caller thread
+                error.append(e)
+
+        thread = threading.Thread(target=_runner, name="praisonai-sync-generate")
+        thread.start()
+        thread.join()
+        if error:
+            raise error[0]
+        return result[0]
+
     @staticmethod
     def get_available_tools() -> List[str]:
         """Return list of available tools for agent assignment."""
@@ -850,18 +904,8 @@ class AutoGenerator(BaseAutoGenerator):
             path = generator.generate()
             _rich_print(path)
         """
-        response = self._structured_completion(
-            response_model=_get_team_models()['TeamStructure'],
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant designed to output complex team structures."},
-                {"role": "user", "content": self.get_user_content()}
-            ]
-        )
-        json_data = json.loads(response.model_dump_json())
-        self.convert_and_save(json_data, merge=merge)
-        full_path = os.path.abspath(self.agent_file)
-        return full_path
-    
+        return self._run_coro_sync(self._agenerate_impl(merge=merge, is_async=False))
+
     async def agenerate(self, merge=False):
         """
         Async version of generate() - generates a team structure for the specified topic.
@@ -880,12 +924,23 @@ class AutoGenerator(BaseAutoGenerator):
                 path = await gen.agenerate()
                 _rich_print(path)
         """
-        response = await self._astructured_completion(
+        return await self._agenerate_impl(merge=merge, is_async=True)
+
+    async def _agenerate_impl(self, merge=False, *, is_async: bool):
+        """Shared generation body for both sync and async entry points.
+
+        The only divergence is ``is_async``, which selects the async provider
+        clients (``agenerate()``) or the blocking sync clients driven on the
+        bridge (sync ``generate()``), preserving the historical sync provider
+        path while keeping merge/save/path-resolution logic in one place.
+        """
+        response = await self._structured_completion_async(
             response_model=_get_team_models()['TeamStructure'],
             messages=[
                 {"role": "system", "content": "You are a helpful assistant designed to output complex team structures."},
                 {"role": "user", "content": self.get_user_content()}
-            ]
+            ],
+            is_async=is_async,
         )
         json_data = json.loads(response.model_dump_json())
         self.convert_and_save(json_data, merge=merge)
@@ -1354,20 +1409,10 @@ Respond with:
         Returns:
             Path to the generated workflow file
         """
-        response = self._structured_completion(
-            response_model=_get_workflow_models()['WorkflowStructure'],
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant that designs workflow structures."},
-                {"role": "user", "content": self._get_prompt(pattern)}
-            ]
+        return self._run_coro_sync(
+            self._agenerate_impl(pattern=pattern, merge=merge, is_async=False)
         )
-        
-        json_data = json.loads(response.model_dump_json())
-        
-        if merge and os.path.exists(self.workflow_file):
-            return self._save_workflow(self.merge_with_existing_workflow(json_data), pattern)
-        return self._save_workflow(json_data, pattern)
-    
+
     async def agenerate(self, pattern: str = "sequential", merge: bool = False) -> str:
         """
         Async version of generate() - Generate a workflow YAML file.
@@ -1380,12 +1425,25 @@ Respond with:
         Returns:
             Path to the generated workflow file
         """
-        response = await self._astructured_completion(
+        return await self._agenerate_impl(pattern=pattern, merge=merge, is_async=True)
+
+    async def _agenerate_impl(
+        self, pattern: str = "sequential", merge: bool = False, *, is_async: bool
+    ) -> str:
+        """Shared generation body for both sync and async entry points.
+
+        ``is_async`` selects the async provider clients (``agenerate()``) or the
+        blocking sync clients driven on the bridge (sync ``generate()``),
+        preserving the historical sync provider path while keeping merge/save
+        logic in one place.
+        """
+        response = await self._structured_completion_async(
             response_model=_get_workflow_models()['WorkflowStructure'],
             messages=[
                 {"role": "system", "content": "You are a helpful assistant that designs workflow structures."},
                 {"role": "user", "content": self._get_prompt(pattern)}
-            ]
+            ],
+            is_async=is_async,
         )
         
         json_data = json.loads(response.model_dump_json())
@@ -1708,18 +1766,12 @@ class JobWorkflowAutoGenerator(BaseAutoGenerator):
         Returns:
             Path to the generated workflow file
         """
-        prompt = self._get_prompt(include_judge, include_approve)
-        
-        response = self._structured_completion(
-            response_model=_get_job_workflow_models()['JobWorkflowStructure'],
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant that designs job workflow structures with AI agent steps."},
-                {"role": "user", "content": prompt}
-            ]
+        return self._run_coro_sync(
+            self._agenerate_impl(
+                include_judge=include_judge, include_approve=include_approve, is_async=False
+            )
         )
-        
-        return self._save_workflow(response)
-    
+
     async def agenerate(self, include_judge: bool = True, include_approve: bool = False) -> str:
         """
         Async version of generate() - Generate a job workflow YAML file.
@@ -1731,14 +1783,29 @@ class JobWorkflowAutoGenerator(BaseAutoGenerator):
         Returns:
             Path to the generated workflow file
         """
+        return await self._agenerate_impl(
+            include_judge=include_judge, include_approve=include_approve, is_async=True
+        )
+
+    async def _agenerate_impl(
+        self, include_judge: bool = True, include_approve: bool = False, *, is_async: bool
+    ) -> str:
+        """Shared generation body for both sync and async entry points.
+
+        ``is_async`` selects the async provider clients (``agenerate()``) or the
+        blocking sync clients driven on the bridge (sync ``generate()``),
+        preserving the historical sync provider path while keeping prompt/save
+        logic in one place.
+        """
         prompt = self._get_prompt(include_judge, include_approve)
         
-        response = await self._astructured_completion(
+        response = await self._structured_completion_async(
             response_model=_get_job_workflow_models()['JobWorkflowStructure'],
             messages=[
                 {"role": "system", "content": "You are a helpful assistant that designs job workflow structures with AI agent steps."},
                 {"role": "user", "content": prompt}
-            ]
+            ],
+            is_async=is_async,
         )
         
         return self._save_workflow(response)

{praisonai-4.6.142 → praisonai-4.6.143}/praisonai/cli/legacy/workflow_commands.py

@@ -398,9 +398,27 @@ def _run_yaml_workflow(self, yaml_file: str, action_args: list, variables: dict
             except ImportError:
                 print("[yellow]Warning: Context management not available[/yellow]")
         
+        # Determine workflow input: CLI --var input takes precedence, then the
+        # YAML top-level `input:` field (stored on workflow.default_input).
+        # An explicit `--var input=` (empty) is respected and NOT replaced by
+        # the default; only an absent input key falls back to default_input.
+        default_input = getattr(workflow, "default_input", "") or ""
+        input_overridden = bool(parsed_vars) and "input" in parsed_vars
+        start_input = parsed_vars["input"] if input_overridden else default_input
+
+        # Seed the runtime `{{input}}` variable when it is not overridden via --var
+        if start_input and not input_overridden:
+            workflow.variables.setdefault("input", start_input)
+
+        if start_input:
+            preview = start_input[:80] + ("..." if len(start_input) > 80 else "")
+            print(f"[cyan]Workflow input: {preview}[/cyan]")
+        else:
+            print("[yellow]Warning: no workflow input — {{input}} will be empty unless --var input=... is set[/yellow]")
+
         # Execute
         print("\n[bold]Executing workflow...[/bold]\n")
-        result = workflow.start("")
+        result = workflow.start(start_input)
         
         if result.get("status") == "completed":
             print("\n[green]✅ Workflow completed successfully![/green]")

praisonai-4.6.143/praisonai/version.py

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

{praisonai-4.6.142 → praisonai-4.6.143}/pyproject.toml

@@ -12,9 +12,9 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.6.145",
-    "praisonai-code>=0.0.41",
-    "praisonai-bot>=0.0.26",
+    "praisonaiagents>=1.6.146",
+    "praisonai-code>=0.0.42",
+    "praisonai-bot>=0.0.27",
     "python-dotenv>=0.19.0",
     "litellm>=1.83.14,<2",
     "PyYAML>=6.0",

praisonai-4.6.142/praisonai/_lockmap.py

@@ -1,143 +0,0 @@
-"""Per-key asyncio.Lock map with bounded LRU eviction and optional TTL.
-
-Use this anywhere you need 'a lock per (user_id|chat_id|key)' instead of
-re-implementing the dict-of-Lock pattern.
-"""
-from __future__ import annotations
-import asyncio
-import threading
-import time
-import weakref
-from collections import OrderedDict
-from typing import Hashable, Dict
-
-
-class LockMap:
-    """Asyncio-safe per-key asyncio.Lock map with automatic cleanup.
-    
-    Provides a lock per key with LRU eviction and TTL-based cleanup to prevent
-    unbounded memory growth in long-running applications.
-    
-    Buckets are keyed by event loop (one loop per OS thread). Structural
-    mutations of the bucket/loop maps are guarded by a ``threading.Lock`` so
-    the same instance can be safely shared across multiple OS threads, each
-    running its own event loop. Per-loop buckets are only ever touched from
-    their owning loop, so intra-loop access remains lock-free.
-    """
-
-    def __init__(self, *, max_entries: int = 10_000, ttl_seconds: float = 3600.0):
-        """Initialize LockMap with bounds.
-        
-        Args:
-            max_entries: Maximum number of locks to cache (LRU eviction)
-            ttl_seconds: Time-to-live for unused locks in seconds
-        """
-        # Bucket locks by event loop to avoid cross-loop issues
-        self._buckets: Dict[int, "OrderedDict[Hashable, tuple[asyncio.Lock, float]]"] = {}
-        self._loop_refs: Dict[int, weakref.ref] = {}
-        # Guards structural mutations of _buckets / _loop_refs across OS threads.
-        self._struct_lock = threading.Lock()
-        self._max = max_entries
-        self._ttl = ttl_seconds
-
-    def get(self, key: Hashable) -> asyncio.Lock:
-        """Get or create a lock for the given key.
-        
-        Args:
-            key: The key to get a lock for
-            
-        Returns:
-            asyncio.Lock for the key
-        """
-        # Get the current running loop
-        loop = asyncio.get_running_loop()
-        loop_id = id(loop)
-
-        # Fast path: a bucket for this loop already exists. The bucket is only
-        # ever mutated by its owning loop's thread, so a single dict read is
-        # safe under CPython's GIL without taking the cross-thread struct lock.
-        bucket = self._buckets.get(loop_id)
-        if bucket is None:
-            # Slow path: structural mutation shared across threads needs the lock.
-            with self._struct_lock:
-                # Clean up dead loops (only on first-touch to avoid per-call cost)
-                self._cleanup_dead_loops_locked()
-
-                # Re-check after acquiring the lock (another thread may have raced).
-                bucket = self._buckets.get(loop_id)
-                if bucket is None:
-                    bucket = OrderedDict()
-                    self._buckets[loop_id] = bucket
-                    self._loop_refs[loop_id] = weakref.ref(loop)
-
-        # From here on only this loop's owning thread touches the bucket.
-        now = time.monotonic()
-        
-        entry = bucket.get(key)
-        if entry is not None:
-            lock, _ = entry
-            # Move to end (most recently used) and update timestamp
-            bucket.move_to_end(key)
-            bucket[key] = (lock, now)
-            return lock
-        
-        # Create new lock + insert + LRU/TTL evict
-        lock = asyncio.Lock()
-        bucket[key] = (lock, now)
-        self._evict_stale_from_bucket(bucket, now)
-        return lock
-
-    def _evict_stale_from_bucket(self, bucket: "OrderedDict", now: float) -> None:
-        """Evict expired and excess entries from a bucket."""
-        # Expire by TTL (only if not currently locked)
-        expired = [
-            k for k, (lock, ts) in bucket.items()
-            if (now - ts) > self._ttl and not lock.locked()
-        ]
-        for k in expired:
-            bucket.pop(k, None)
-        
-        # Cap by LRU (don't evict locks currently held)
-        seen = set()
-        while len(bucket) > self._max:
-            k, (lock, _) = next(iter(bucket.items()))
-            if k in seen:
-                # All remaining locks are held; give up to avoid infinite loop
-                break
-            if lock.locked():
-                # Don't evict locks currently held; bump them to the end
-                bucket.move_to_end(k)
-                seen.add(k)
-                # Continue trying to evict other unlocked entries
-                continue
-            bucket.popitem(last=False)
-            break
-    
-    def _cleanup_dead_loops_locked(self) -> None:
-        """Remove buckets for event loops that no longer exist.
-
-        Caller must hold ``self._struct_lock``.
-        """
-        dead_loops = [
-            loop_id
-            for loop_id, ref in self._loop_refs.items()
-            if (loop := ref()) is None or loop.is_closed()
-        ]
-        for loop_id in dead_loops:
-            self._loop_refs.pop(loop_id, None)
-            self._buckets.pop(loop_id, None)
-
-    def drop(self, key: Hashable) -> None:
-        """Manually remove a lock for the given key."""
-        # Get the current running loop
-        loop = asyncio.get_running_loop()
-        loop_id = id(loop)
-        with self._struct_lock:
-            bucket = self._buckets.get(loop_id)
-        if bucket is not None:
-            bucket.pop(key, None)
-
-    def size(self) -> int:
-        """Return current number of cached locks across all buckets."""
-        with self._struct_lock:
-            return sum(len(bucket) for bucket in self._buckets.values())

praisonai-4.6.142/praisonai/version.py

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