PraisonAI 4.6.72__tar.gz → 4.6.75__tar.gz

{praisonai-4.6.72 → praisonai-4.6.75}/PKG-INFO

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

{praisonai-4.6.72 → praisonai-4.6.75}/PraisonAI.egg-info/PKG-INFO

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

{praisonai-4.6.72 → praisonai-4.6.75}/PraisonAI.egg-info/SOURCES.txt

@@ -24,7 +24,6 @@ praisonai/async_agent_scheduler.py
 praisonai/auto.py
 praisonai/profiler.py
 praisonai/setup.py
-praisonai/test.py
 praisonai/tool_registry.py
 praisonai/tool_resolver.py
 praisonai/train.py
@@ -255,6 +254,7 @@ praisonai/cli/commands/validate.py
 praisonai/cli/commands/version.py
 praisonai/cli/commands/workflow.py
 praisonai/cli/configuration/__init__.py
+praisonai/cli/configuration/config.schema.json
 praisonai/cli/configuration/credentials.py
 praisonai/cli/configuration/loader.py
 praisonai/cli/configuration/paths.py
@@ -445,6 +445,7 @@ praisonai/cli/interactive/frontends/rich_frontend.py
 praisonai/cli/interactive/frontends/textual_frontend.py
 praisonai/cli/output/__init__.py
 praisonai/cli/output/console.py
+praisonai/cli/output/event_bridge.py
 praisonai/cli/session/__init__.py
 praisonai/cli/session/unified.py
 praisonai/cli/state/__init__.py
@@ -765,6 +766,8 @@ praisonai/scheduler/_dispatch.py
 praisonai/scheduler/agent_scheduler.py
 praisonai/scheduler/async_agent_scheduler.py
 praisonai/scheduler/base.py
+praisonai/scheduler/blueprint_catalogue.py
+praisonai/scheduler/condition_gate.py
 praisonai/scheduler/daemon_manager.py
 praisonai/scheduler/deployment.py
 praisonai/scheduler/enhanced_executor.py
@@ -772,6 +775,7 @@ praisonai/scheduler/executor.py
 praisonai/scheduler/run_policy.py
 praisonai/scheduler/shared.py
 praisonai/scheduler/state_manager.py
+praisonai/scheduler/suggestion_engine.py
 praisonai/scheduler/yaml_loader.py
 praisonai/security/__init__.py
 praisonai/security/audit.py

{praisonai-4.6.72 → praisonai-4.6.75}/PraisonAI.egg-info/requires.txt

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

{praisonai-4.6.72 → praisonai-4.6.75}/praisonai/_lockmap.py

@@ -5,6 +5,7 @@ re-implementing the dict-of-Lock pattern.
 """
 from __future__ import annotations
 import asyncio
+import threading
 import time
 import weakref
 from collections import OrderedDict
@@ -17,9 +18,11 @@ class LockMap:
     Provides a lock per key with LRU eviction and TTL-based cleanup to prevent
     unbounded memory growth in long-running applications.
     
-    Note: Safe for use within a single asyncio event loop (cooperative
-    multitasking means no interleaving between non-awaited calls), but NOT
-    safe for concurrent access from multiple OS threads.
+    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):
@@ -32,6 +35,8 @@ class LockMap:
         # 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
 
@@ -47,16 +52,25 @@ class LockMap:
         # Get the current running loop
         loop = asyncio.get_running_loop()
         loop_id = id(loop)
-        
-        # Clean up dead loops
-        self._cleanup_dead_loops()
-        
-        # Get or create bucket for this loop
-        if loop_id not in self._buckets:
-            self._buckets[loop_id] = OrderedDict()
-            self._loop_refs[loop_id] = weakref.ref(loop)
-        
-        bucket = self._buckets[loop_id]
+
+        # 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)
@@ -99,27 +113,31 @@ class LockMap:
             bucket.popitem(last=False)
             break
     
-    def _cleanup_dead_loops(self) -> None:
-        """Remove buckets for event loops that no longer exist."""
-        dead_loops = []
-        for loop_id, ref in self._loop_refs.items():
-            loop = ref()
-            if loop is None or loop.is_closed():
-                dead_loops.append(loop_id)
-        
+    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:
-            del self._loop_refs[loop_id]
-            if loop_id in self._buckets:
-                del self._buckets[loop_id]
+            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)
-        if loop_id in self._buckets:
-            self._buckets[loop_id].pop(key, None)
+        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."""
-        return sum(len(bucket) for bucket in self._buckets.values())
+        with self._struct_lock:
+            return sum(len(bucket) for bucket in self._buckets.values())

{praisonai-4.6.72 → praisonai-4.6.75}/praisonai/agents_generator.py

@@ -16,7 +16,7 @@ from .version import __version__
 
 # Import new architecture components
 from .framework_adapters.base import FrameworkAdapter
-from .tool_registry import ToolRegistry
+from .framework_adapters.registry import FrameworkAdapterRegistry, get_default_registry
 
 
 def _rich_print(*args, **kwargs):
@@ -237,15 +237,9 @@ class AgentsGenerator:
         elif os.environ.get('LOGLEVEL'):
             self.logger.setLevel(getattr(logging, os.environ.get('LOGLEVEL', 'INFO').upper(), logging.INFO))
         
-        # Keep tool registry for backward compatibility with autogen adapters
-        self.tool_registry = ToolRegistry()
-        
-        # Initialize tool resolver with the registry wired in (single source of truth for tool resolution)
+        # Initialize tool resolver (single source of truth for tool resolution)
         from .tool_resolver import ToolResolver
-        self.tool_resolver = ToolResolver(registry=self.tool_registry)
-        
-        # Wire resolver back to registry for cache invalidation
-        self.tool_registry.set_resolver(self.tool_resolver)
+        self.tool_resolver = ToolResolver()
         
         # DI-friendly: tests/multi-tenant runtimes pass their own registry;
         # CLI users get the process default.
@@ -254,11 +248,6 @@ class AgentsGenerator:
         # Defer framework adapter creation until YAML is loaded
         # This fixes the issue where empty framework string fails before YAML framework is read
         self.framework_adapter = None
-        
-        # Only autogen-family adapters need the autogen tool shim
-        # Note: autogen_v2 is also part of the autogen family
-        if framework and framework in {"autogen", "autogen_v2", "autogen_v4", "ag2"}:
-            self.tool_registry.register_builtin_autogen_adapters()
 
     def _get_framework_adapter(self, framework: str) -> FrameworkAdapter:
         """

{praisonai-4.6.72 → praisonai-4.6.75}/praisonai/bots/_commands.py

@@ -95,6 +95,11 @@ class CommandRegistry:
         self.register("stop", {"description": "Cancel current agent task", "builtin": True})
         self.register("whoami", {"description": "Show your user info and permissions", "builtin": True})
         self.register("sethome", {"description": "Set this chat as the home channel for scheduled deliveries", "builtin": True})
+        # New runtime control commands
+        self.register("model", {"description": "Switch LLM model for this session", "builtin": True})
+        self.register("usage", {"description": "Show token usage and estimated cost", "builtin": True})
+        self.register("compress", {"description": "Compress conversation to free context window", "builtin": True})
+        self.register("queue", {"description": "Queue a follow-up message", "builtin": True})
     
     def register(
         self, 
@@ -412,3 +417,259 @@ def handle_run_status_command(
         return f"⚡ Task running for {elapsed_str}{pending_info}"
     except Exception as e:
         return f"Error getting status: {e}"
+
+
+def handle_model_command(
+    session_manager,
+    user_id: str,
+    model_name: Optional[str] = None,
+    agent: Optional["Agent"] = None,
+) -> str:
+    """Handle /model command for runtime model switching.
+    
+    Args:
+        session_manager: BotSessionManager instance
+        user_id: User ID
+        model_name: Optional model name to switch to
+        agent: Current agent instance
+        
+    Returns:
+        Response message
+    """
+    # Resolve the storage key so the override is keyed identically to how
+    # chat() looks it up (handles cross-platform identity resolution).
+    storage_key = user_id
+    if hasattr(session_manager, '_storage_key'):
+        try:
+            storage_key = session_manager._storage_key(user_id)
+        except Exception:
+            storage_key = user_id
+
+    if not model_name:
+        # Show current model — prefer the per-user override if one is set,
+        # otherwise fall back to the agent's configured model.
+        overrides = getattr(session_manager, '_model_overrides', {})
+        current = overrides.get(storage_key)
+        if not current and agent and hasattr(agent, 'llm'):
+            current = agent.llm if isinstance(agent.llm, str) else "default"
+        if not current:
+            return "No model configured. Use /model <name> to set one."
+        return f"Current model: {current}\nUse /model <name> to switch (e.g., /model gpt-4o)"
+
+    # Store the override per user. chat() applies it inside the per-agent lock
+    # and restores the original afterwards, so the shared Agent instance is
+    # never mutated for other concurrent users.
+    if not hasattr(session_manager, '_model_overrides'):
+        session_manager._model_overrides = {}
+    session_manager._model_overrides[storage_key] = model_name
+
+    return f"✅ Model switched to {model_name} for this conversation."
+
+
+def handle_usage_command(
+    session_manager,
+    user_id: str,
+    agent: Optional["Agent"] = None,
+) -> str:
+    """Handle /usage command to show token usage and cost.
+    
+    Args:
+        session_manager: BotSessionManager instance  
+        user_id: User ID
+        agent: Current agent instance
+        
+    Returns:
+        Response message with usage info
+    """
+    # Check for usage tracking via hooks or session metadata
+    usage_info = {}
+    
+    # Try to get usage from session metadata if tracked
+    if hasattr(session_manager, '_usage_tracker'):
+        usage_info = session_manager._usage_tracker.get(user_id, {})
+    
+    # Check agent's token tracking if available
+    if agent and hasattr(agent, 'get_token_usage'):
+        try:
+            agent_usage = agent.get_token_usage()
+            usage_info.update(agent_usage)
+        except Exception:
+            pass
+    
+    # Format usage response
+    if not usage_info:
+        return "No usage data available. Usage tracking may not be enabled."
+    
+    total_tokens = usage_info.get('total_tokens', 0)
+    prompt_tokens = usage_info.get('prompt_tokens', 0)
+    completion_tokens = usage_info.get('completion_tokens', 0)
+    
+    # Estimate cost (rough estimates, would need model-specific pricing)
+    cost_estimate = total_tokens * 0.00002  # Default estimate
+    
+    lines = [
+        "📊 Token Usage",
+        f"Total: {total_tokens:,} tokens",
+    ]
+    
+    if prompt_tokens or completion_tokens:
+        lines.append(f"Prompt: {prompt_tokens:,} | Completion: {completion_tokens:,}")
+    
+    lines.append(f"Est. cost: ${cost_estimate:.4f}")
+    
+    return "\n".join(lines)
+
+
+def handle_compress_command(
+    session_manager,
+    user_id: str,
+    agent: Optional["Agent"] = None,
+) -> str:
+    """Handle /compress command for context window management.
+    
+    Args:
+        session_manager: BotSessionManager instance
+        user_id: User ID  
+        agent: Current agent instance
+        
+    Returns:
+        Response message
+    """
+    try:
+        # Get user's chat history
+        if not hasattr(session_manager, '_histories'):
+            return "❌ No conversation history to compress."
+        
+        storage_key = user_id
+        if hasattr(session_manager, '_storage_key'):
+            storage_key = session_manager._storage_key(user_id)
+        
+        history = session_manager._histories.get(storage_key, [])
+        if len(history) < 10:
+            return "ℹ️ Conversation too short to compress (need at least 10 messages)."
+        
+        # Import optimizer
+        try:
+            from praisonaiagents.context.optimizer import SummarizeOptimizer
+            from praisonaiagents.context.tokens import estimate_messages_tokens
+        except ImportError:
+            # Fallback to simple truncation
+            original_len = len(history)
+            # Keep system messages and last 5 exchanges
+            system_msgs = [m for m in history if m.get("role") == "system"]
+            other_msgs = [m for m in history if m.get("role") != "system"]
+            compressed = system_msgs + other_msgs[-10:]  # Keep last 5 exchanges (10 messages)
+            
+            session_manager._histories[storage_key] = compressed
+            removed = original_len - len(compressed)
+            
+            return f"✅ Compressed conversation: removed {removed} older messages."
+        
+        # Use SummarizeOptimizer if available
+        original_tokens = estimate_messages_tokens(history)
+        optimizer = SummarizeOptimizer(preserve_recent=10)
+        
+        # Target 50% reduction
+        target_tokens = original_tokens // 2
+        compressed_history, result = optimizer.optimize(history, target_tokens)
+        
+        # Update history
+        session_manager._histories[storage_key] = compressed_history
+        
+        # Persist if store available
+        if hasattr(session_manager, '_store') and session_manager._store:
+            try:
+                session_manager._persist(storage_key)
+            except Exception:
+                pass
+        
+        tokens_saved = result.tokens_saved if hasattr(result, 'tokens_saved') else 0
+        messages_removed = len(history) - len(compressed_history)
+        
+        return f"✅ Compressed {messages_removed} messages, freed ~{tokens_saved:,} tokens."
+        
+    except Exception as e:
+        logger.error(f"Compression failed: {e}")
+        return f"❌ Compression failed: {e}"
+
+
+def handle_queue_command(
+    session_manager,
+    user_id: str,
+    message_text: Optional[str] = None,
+    run_control: Optional["SessionRunControl"] = None,
+) -> str:
+    """Handle /queue command for message queuing.
+
+    Delegates to the canonical :class:`SessionRunControl` pending slot, which
+    is the only mechanism that is actually drained by the gateway run loop
+    (``chat_with_run_control`` calls ``next_pending``/``finish_run``). A
+    message is only meaningful to queue while a run is in flight; if the bot
+    is idle there is nothing to run "after", so the user is told to just send
+    the message normally instead of being given a false promise.
+
+    Args:
+        session_manager: BotSessionManager instance
+        user_id: User ID
+        message_text: Optional message to queue
+        run_control: SessionRunControl instance (falls back to
+            ``session_manager._run_control`` when not supplied)
+
+    Returns:
+        Response message
+    """
+    # Resolve run control from the explicit arg or the session manager.
+    if run_control is None:
+        run_control = getattr(session_manager, "_run_control", None)
+
+    if run_control is None:
+        return (
+            "ℹ️ Message queuing isn't enabled for this bot. "
+            "Just send your message and it will be processed."
+        )
+
+    if not message_text:
+        # Show whether a follow-up is currently pending for this user.
+        try:
+            status = run_control.get_run_status(user_id)
+        except Exception:
+            status = {}
+        if status.get("has_pending"):
+            preview = status.get("pending_preview", "")
+            return f"📝 Pending follow-up: {preview}"
+        return "No follow-up queued. Use /queue <message> to add one while a task is running."
+
+    # Submit through run control so the message is parked in the pending slot
+    # that the run loop actually drains after the current turn completes.
+    import asyncio
+
+    from ._run_control import RunDecision
+
+    async def _submit() -> "RunDecision":
+        return await run_control.submit(user_id, message_text)
+
+    try:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop is not None and loop.is_running():
+            # Schedule on the running loop; we can't block-await from here.
+            loop.create_task(_submit())
+            return "⏳ Follow-up noted — it will run after the current task completes."
+
+        decision = asyncio.run(_submit())
+    except Exception as e:  # noqa: BLE001 - surface a friendly message
+        return f"❌ Could not queue message: {e}"
+
+    if decision == RunDecision.RUN_NOW:
+        return (
+            "ℹ️ No task is currently running, so there's nothing to queue behind. "
+            "Send your message normally to run it now."
+        )
+    if decision == RunDecision.MERGED:
+        return "⏳ Added to your pending follow-up — it will run after the current task completes."
+    if decision == RunDecision.STEERED:
+        return "🧭 Injected into the running task as live guidance."
+    return "⏳ Follow-up queued — it will run after the current task completes."

{praisonai-4.6.72 → praisonai-4.6.75}/praisonai/bots/_config_schema.py

@@ -76,10 +76,50 @@ class SessionResetConfigSchema(BaseModel):
         return self
 
 
+class SessionCompactionConfigSchema(BaseModel):
+    """Schema for session history compaction configuration.
+
+    When enabled, older turns in a long-lived bot/gateway session are
+    summarised (rather than hard-truncated) once the history exceeds the
+    configured budget, so context survives across weeks-long conversations
+    and restarts. Disabled by default to preserve legacy behaviour.
+    """
+    enabled: bool = False
+    strategy: str = "summarize"  # truncate | sliding | summarize | smart | prune | llm_summarize
+    max_messages: int = 100  # Approx. compaction threshold (converted to a token budget; max_history remains a hard cap)
+    max_tokens: Optional[int] = None  # Optional token-based budget (overrides messages)
+    keep_recent: int = 10  # Number of most-recent messages kept verbatim
+
+    @field_validator("strategy")
+    @classmethod
+    def validate_strategy(cls, v: str) -> str:
+        allowed = {"truncate", "sliding", "summarize", "smart", "prune", "llm_summarize"}
+        if v not in allowed:
+            raise ValueError(
+                f"Invalid compaction strategy '{v}'. Must be one of: {', '.join(sorted(allowed))}"
+            )
+        return v
+
+    @field_validator("max_messages")
+    @classmethod
+    def validate_max_messages(cls, v: int) -> int:
+        if v < 1:
+            raise ValueError("max_messages must be at least 1")
+        return v
+
+    @field_validator("keep_recent")
+    @classmethod
+    def validate_keep_recent(cls, v: int) -> int:
+        if v < 0:
+            raise ValueError("keep_recent must be non-negative")
+        return v
+
+
 class SessionConfigSchema(BaseModel):
     """Schema for session configuration."""
     max_history: int = 100
     reset: Optional[SessionResetConfigSchema] = None
+    compaction: Optional[SessionCompactionConfigSchema] = None
 
 
 class StreamingConfigSchema(BaseModel):
@@ -156,6 +196,7 @@ class ChannelConfigSchema(BaseModel):
     user_allowed_commands: Optional[str] = None  # Comma-separated list of allowed commands
     routes: Dict[str, str] = Field(default_factory=dict)  # Context -> agent_id mapping
     routing: Optional[Dict[str, str]] = None  # Alias for routes
+    bindings: List[Dict[str, Any]] = Field(default_factory=list)  # Priority-ordered route bindings (Issue #2225)
     webhook_url: Optional[str] = None
     webhook_port: int = 8080
     streaming: Optional[StreamingConfigSchema] = None

{praisonai-4.6.72 → praisonai-4.6.75}/praisonai/bots/_protocol_mixin.py

@@ -118,6 +118,37 @@ class MessageHookMixin:
             return None
         return getattr(agent, '_hook_runner', None)
 
+    async def _default_health(self) -> Any:
+        """Build a :class:`HealthResult` shared by all bot adapters (DRY).
+
+        Combines ``self.probe()`` liveness with ``self._is_running``,
+        ``self._started_at`` and ``self._session``. The only per-adapter
+        difference is ``self.platform``, which each adapter already exposes.
+        Adapters delegate via ``health()`` but may override for bespoke needs.
+        """
+        from praisonaiagents.bots import HealthResult
+
+        probe_result = await self.probe()  # type: ignore[attr-defined]
+        started_at = getattr(self, '_started_at', None)
+        uptime = (time.time() - started_at) if started_at else None
+        session = getattr(self, '_session', None)
+        if session is not None and hasattr(session, '_histories'):
+            session_count = len(session._histories)
+        elif session is not None and hasattr(session, 'active_count'):
+            session_count = session.active_count()
+        else:
+            session_count = 0
+        is_running = getattr(self, '_is_running', False)
+        return HealthResult(
+            ok=is_running and probe_result.ok,
+            platform=self.platform,  # type: ignore[attr-defined]
+            is_running=is_running,
+            uptime_seconds=uptime,
+            probe=probe_result,
+            sessions=session_count,
+            error=probe_result.error if not probe_result.ok else None,
+        )
+
     def fire_message_received(self, message: Any) -> None:
         """Fire MESSAGE_RECEIVED hook when an incoming message arrives.