PraisonAI 4.6.74__tar.gz → 4.6.75__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.74
+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.74
+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.74 → praisonai-4.6.75}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.74
+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.74
+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.74 → 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

{praisonai-4.6.74 → 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.74
+praisonaiagents>=1.6.75
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.74 → 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.74 → 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.74 → 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.
 

{praisonai-4.6.74 → praisonai-4.6.75}/praisonai/bots/_run_control.py

@@ -52,6 +52,7 @@ class RunDecision(Enum):
     QUEUED = "queued"            # Current run active, message queued for next turn
     MERGED = "merged"            # Message merged into existing pending slot
     INTERRUPTED = "interrupted"  # Current run was interrupted, start new run
+    STEERED = "steered"          # Message injected into the live run via steering
 
 
 class BusyMode(Enum):
@@ -71,6 +72,7 @@ class SessionRunState:
         self.interrupt_controller: Optional["InterruptController"] = None
         self.start_time: Optional[float] = None
         self.last_activity: float = time.time()  # Always track activity for cleanup
+        self.agent: Optional[Any] = None  # Live agent handle for STEER mode
 
 
 class SessionRunControl:
@@ -163,11 +165,25 @@ class SessionRunControl:
                 return RunDecision.INTERRUPTED
                 
             elif self._busy_mode == BusyMode.STEER:
-                # Try to inject into running agent via steering
-                # Note: This requires the agent to have steering enabled
-                # For now, we'll fall back to queueing
-                logger.warning("Steer mode is not yet implemented, falling back to queue mode")
-                # TODO: Implement steering integration when agent reference is available
+                # Inject the message into the running agent via steering so the
+                # current turn folds in the new guidance (preserving partial
+                # progress) instead of cancelling or waiting for the run to end.
+                agent = session.agent
+                if agent is not None and getattr(agent, "message_steering_enabled", False):
+                    try:
+                        # priority 30 == SteeringPriority.INTERRUPT (immediate)
+                        msg_id = agent.steer(text, priority=30)
+                    except Exception as exc:  # noqa: BLE001 - fall back safely
+                        logger.warning("Steering injection failed (%s), falling back to queue", exc)
+                    else:
+                        if msg_id:
+                            return RunDecision.STEERED
+                        logger.warning("Steering returned no message id, falling back to queue")
+                else:
+                    logger.warning(
+                        "Steer mode requested but agent has no steering enabled, falling back to queue"
+                    )
+                # Safe fallback: queue the message below.
                 
             # Default to queue mode (or steer fallback)
             if session.pending_message is None:
@@ -196,6 +212,8 @@ class SessionRunControl:
             action = "added to pending request"
         elif decision == RunDecision.INTERRUPTED:
             return "⚠️ Previous task cancelled, starting your new request"
+        elif decision == RunDecision.STEERED:
+            return "🧭 Steering the current task with your new guidance"
         else:
             return ""  # No ack needed for RUN_NOW
             
@@ -235,6 +253,7 @@ class SessionRunControl:
             session.pending_message = None
             session.interrupt_controller = None
             session.start_time = None
+            session.agent = None
             
             return True
 
@@ -269,6 +288,21 @@ class SessionRunControl:
                 session.is_running = False
                 session.interrupt_controller = None
                 session.start_time = None
+                session.agent = None
+
+    def register_agent(self, user_id: str, agent: Any) -> None:
+        """Register the live agent handle for a user's run (for STEER mode).
+
+        The gateway calls this once the run is active so that subsequent
+        mid-run messages in STEER mode can be injected into the agent's
+        steering queue via ``agent.steer(...)``.
+
+        Args:
+            user_id: User identifier
+            agent: The Agent instance handling this user's run
+        """
+        session = self._get_session(user_id)
+        session.agent = agent
 
     def get_interrupt_controller(self, user_id: str) -> Optional["InterruptController"]:
         """Get the interrupt controller for a user's current run.

{praisonai-4.6.74 → praisonai-4.6.75}/praisonai/bots/_session.py

@@ -110,6 +110,11 @@ class BotSessionManager:
         # Run timeout and active run tracking for cancellation support
         self._run_timeout = run_timeout
         self._active_runs: Dict[str, Any] = {}  # user_id -> InterruptController
+        # Per-user model overrides set via the /model command. Applied per-turn
+        # inside the agent lock in chat() and restored afterwards so a shared
+        # Agent instance never leaks one user's model to another. Keyed by
+        # storage_key (same as _histories).
+        self._model_overrides: Dict[str, Any] = {}
         # Session reset policy for automatic lifecycle management
         self._reset_policy = reset_policy or SessionResetPolicy(mode="none")
         # Track storage keys we've already fired SESSION_START for, so the
@@ -525,7 +530,21 @@ class BotSessionManager:
                     async with agent_lock:
                         saved_history = agent.chat_history
                         agent.chat_history = user_history
-                        
+
+                        # Apply a per-user model override (set via the /model
+                        # command) for the duration of this turn only. The swap
+                        # happens inside the per-agent lock and is restored in
+                        # the finally below, so a shared Agent instance never
+                        # leaks one user's model to another concurrent user.
+                        _model_overridden = False
+                        _saved_llm = None
+                        _override = self._model_overrides.get(self._storage_key(user_id))
+                        if _override is not None and hasattr(agent, "llm"):
+                            _saved_llm = agent.llm
+                            if _override != _saved_llm:
+                                agent.llm = _override
+                                _model_overridden = True
+
                         # Create interrupt controller for this run and register it
                         try:
                             from praisonaiagents.agent.interrupt import InterruptController
@@ -628,6 +647,10 @@ class BotSessionManager:
                             raise
                         finally:
                             agent.chat_history = saved_history
+                            # Restore the agent's original model if we applied a
+                            # per-user override for this turn.
+                            if _model_overridden:
+                                agent.llm = _saved_llm
                             # Clean up active run tracking
                             if controller:
                                 self._active_runs.pop(storage_key, None)
@@ -702,6 +725,19 @@ class BotSessionManager:
         # Submit message to run control
         decision = await self._run_control.submit(user_id, prompt)
         
+        if decision == RunDecision.STEERED:
+            # Message was injected into the live run via steering; the running
+            # turn folds in the new guidance without a separate response here.
+            ack_msg = await self._run_control.get_busy_ack_message(user_id, decision)
+            return {
+                "response": ack_msg,
+                "metadata": {
+                    "run_control": True,
+                    "decision": decision.value,
+                    "steered": True,
+                }
+            }
+
         if decision in (RunDecision.QUEUED, RunDecision.MERGED):
             # Message was queued or merged, return acknowledgment
             ack_msg = await self._run_control.get_busy_ack_message(user_id, decision)
@@ -713,7 +749,7 @@ class BotSessionManager:
                     "queued": True
                 }
             }
-        
+
         # We're running now (RUN_NOW or INTERRUPTED)
         current_prompt = prompt
         last_response = ""
@@ -725,6 +761,17 @@ class BotSessionManager:
             interrupt_controller = None
 
             if last_decision in (RunDecision.RUN_NOW, RunDecision.INTERRUPTED):
+                # Register the live agent for each fresh run so that mid-run
+                # STEER messages can be injected into it. finish_run() clears the
+                # handle after every turn, so re-register on each pending iteration
+                # too (otherwise STEER silently falls back to QUEUE after the
+                # first run).
+                if hasattr(self._run_control, "register_agent"):
+                    try:
+                        self._run_control.register_agent(user_id, agent)
+                    except Exception:  # noqa: BLE001 - registration is best-effort
+                        logger.debug("Failed to register agent for steering", exc_info=True)
+
                 interrupt_controller = self._run_control.get_interrupt_controller(user_id)
 
             status = self._run_control.get_run_status(user_id)

{praisonai-4.6.74 → praisonai-4.6.75}/praisonai/bots/agentmail.py

@@ -919,17 +919,4 @@ class AgentMailBot(ChatCommandMixin, MessageHookMixin):
     
     async def health(self) -> HealthResult:
         """Get health status of the AgentMail bot."""
-        probe_result = await self.probe()
-        
-        uptime = 0.0
-        if self._started_at:
-            uptime = time.time() - self._started_at
-        
-        return HealthResult(
-            ok=self._is_running and probe_result.ok,
-            platform="agentmail",
-            is_running=self._is_running,
-            uptime_seconds=uptime,
-            probe=probe_result,
-            sessions=self._session.active_count() if hasattr(self._session, 'active_count') else 0,
-        )
+        return await self._default_health()

{praisonai-4.6.74 → praisonai-4.6.75}/praisonai/bots/discord.py

@@ -25,7 +25,15 @@ from praisonaiagents.bots import (
     PlatformCapabilities,
 )
 
-from ._commands import format_status, format_help, handle_stop_command
+from ._commands import (
+    format_status, 
+    format_help, 
+    handle_stop_command,
+    handle_model_command,
+    handle_usage_command,
+    handle_compress_command,
+    handle_queue_command
+)
 from ._session import BotSessionManager
 from ._debounce import InboundDebouncer
 from ._ack import AckReactor
@@ -244,6 +252,32 @@ class DiscordBot(ChatCommandMixin, MessageHookMixin):
                     response = handle_stop_command(self._session, user_id)
                     await message.reply(response)
                     return
+                elif command == "model":
+                    user_id = str(message.author.id)
+                    # Extract model name from message
+                    parts = bot_message.text.split(maxsplit=1)
+                    model_name = parts[1] if len(parts) > 1 else None
+                    response = handle_model_command(self._session, user_id, model_name, self._agent)
+                    await message.reply(response)
+                    return
+                elif command == "usage":
+                    user_id = str(message.author.id)
+                    response = handle_usage_command(self._session, user_id, self._agent)
+                    await message.reply(response)
+                    return
+                elif command == "compress":
+                    user_id = str(message.author.id)
+                    response = handle_compress_command(self._session, user_id, self._agent)
+                    await message.reply(response)
+                    return
+                elif command == "queue":
+                    user_id = str(message.author.id)
+                    # Extract message text from command
+                    parts = bot_message.text.split(maxsplit=1)
+                    message_text = parts[1] if len(parts) > 1 else None
+                    response = handle_queue_command(self._session, user_id, message_text)
+                    await message.reply(response)
+                    return
                 elif command and command in self._command_handlers:
                     handler = self._command_handlers[command]
                     try:
@@ -550,16 +584,7 @@ class DiscordBot(ChatCommandMixin, MessageHookMixin):
 
     async def health(self):
         """Get detailed health status of the Discord bot."""
-        from praisonaiagents.bots import HealthResult
-        probe_result = await self.probe()
-        uptime = (time.time() - self._started_at) if self._started_at else None
-        session_count = len(self._session._histories) if hasattr(self._session, '_histories') else 0
-        return HealthResult(
-            ok=self._is_running and probe_result.ok, platform="discord",
-            is_running=self._is_running, uptime_seconds=uptime,
-            probe=probe_result, sessions=session_count,
-            error=probe_result.error if not probe_result.ok else None,
-        )
+        return await self._default_health()
 
     def _format_status(self) -> str:
         """Format /status response."""