Release v4.5.18

Author: MervinPraison

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.5.17" \
+    "praisonai>=4.5.18" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.5.17" \
+    "praisonai>=4.5.18" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.5.17" \
+    "praisonai>=4.5.18" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

src/praisonai-agents/praisonaiagents/output/status.py

@@ -80,13 +80,15 @@ def __init__(
         use_color: bool = True,
         show_timestamps: bool = True,  # NEW: control timestamp display
         show_metrics: bool = False,  # Enable metrics display for debug mode
+        show_tool_output: bool = True,  # Show tool result output inline
     ):
         self._file = file or sys.stderr  # Use stderr to not interfere with agent output
         self._format = format
         self._redact = redact
         self._use_color = use_color
         self._show_timestamps = show_timestamps
         self._show_metrics = show_metrics
+        self._show_tool_output = show_tool_output
         self._console = None
         self._tool_start_times: Dict[str, float] = {}
         self._lock = threading.Lock()  # Per-sink lock for thread safety
@@ -120,12 +122,12 @@ def _format_args(self, args: Optional[Dict[str, Any]]) -> str:
         parts = []
         for k, v in (redacted or {}).items():
             if isinstance(v, str):
-                v_str = f'"{_truncate(v, 30)}"'
+                v_str = f'"{_truncate(v, 80)}"'
             else:
-                v_str = _truncate(str(v), 30)
+                v_str = _truncate(str(v), 80)
             parts.append(f"{k}={v_str}")
 
-        return _truncate(", ".join(parts), 80)
+        return _truncate(", ".join(parts), 200)
 
     def agent_start(self, agent_name: str) -> None:
         """Record agent start."""
@@ -185,8 +187,8 @@ def llm_end(
         """Record LLM call end with optional metrics for debug mode."""
         ts = time.time()
 
-        # Use latency_ms if provided, otherwise calculate from start time
-        if latency_ms is not None:
+        # Use latency_ms if provided and positive, otherwise calculate from start time
+        if latency_ms is not None and latency_ms > 0:
             duration_ms = latency_ms
         elif duration_ms is None and hasattr(self, '_llm_start_time'):
             start_ts = self._llm_start_time
@@ -267,9 +269,13 @@ def tool_end(
                 args_str = self._format_args(self._pending_tool_args)
 
             result_str = ""
-            if result_summary:
-                result_str = f" → {_truncate(result_summary, 50)}"
+            if self._show_tool_output:
+                if result_summary:
+                    result_str = f" → {_truncate(result_summary, 50)}"
+                elif error_message:
+                    result_str = f" → ✗ {_truncate(error_message, 50)}"
             elif error_message:
+                # Always show errors even when output is hidden
                 result_str = f" → ✗ {_truncate(error_message, 50)}"
 
             color = "cyan" if status == "ok" else "red"
@@ -285,9 +291,9 @@ def output(self, content: str, agent_name: Optional[str] = None) -> None:
             separator = "─" * 50
             self._emit_text(separator, ts, "dim", show_timestamp=False)
             self._emit_text("Final Output:", ts, "bold", show_timestamp=False)
-            # Print actual content without truncation for final output
+            # Print actual content to stdout (not stderr) so users see it
             with self._lock:  # Thread-safe output
-                print(content, file=self._file)
+                print(content)
 
     def _emit_text(self, message: str, ts: float, style: str = None, show_timestamp: bool = True) -> None:
         """Emit a text line. Thread-safe for multi-agent execution."""
@@ -320,6 +326,7 @@ def enable_status_output(
     use_color: bool = True,
     show_timestamps: bool = True,
     show_metrics: bool = False,  # Enable metrics for debug mode
+    show_tool_output: bool = True,  # Show tool result output inline
 ) -> StatusOutput:
     """
     Enable actions output mode globally.
@@ -334,6 +341,7 @@ def enable_status_output(
         use_color: Whether to use colored output (default: True)
         show_timestamps: Whether to show timestamps (default: True)
         show_metrics: Whether to show token/cost metrics (default: False)
+        show_tool_output: Whether to show tool result output inline (default: True)
     
     Returns:
         StatusOutput instance for programmatic access
@@ -350,6 +358,7 @@ def enable_status_output(
         use_color=use_color,
         show_timestamps=show_timestamps,
         show_metrics=show_metrics,
+        show_tool_output=show_tool_output,
     )
     _status_output_enabled = True
 

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "1.5.17"
+version = "1.5.18"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"

src/praisonai-agents/uv.lock

@@ -3,8 +3,8 @@ class Praisonai < Formula
 
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.17.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.17.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.18.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.18.tar.gz | shasum -a 256`.split.first
     license "MIT"
 
     depends_on "python@3.11"

src/praisonai/praisonai.rb

@@ -99,11 +99,16 @@ def is_legacy_invocation(argv: List[str]) -> bool:
         '-p', '--autonomy', '--trust',
         '--sandbox', '--external-agent', '--compare', '--interval', '--timeout',
         '--max-cost', '--rpm', '--tpm', '--temperature',
+        # Display flags (verbosity ladder + machine output)
+        '--output', '--flow',
     ]
 
     for arg in argv:
         if arg in legacy_flags:
             return True
+        # Handle -vv, -qq, -vvv etc. (count flags not in Typer)
+        if len(arg) > 2 and arg.startswith('-') and not arg.startswith('--') and arg[1:] in ('vv', 'qq', 'vvv', 'qqq'):
+            return True
 
     # Check if first arg is a legacy command not in Typer
     if first_arg in LEGACY_COMMANDS and first_arg not in TYPER_COMMANDS:

src/praisonai/praisonai/cli/legacy.py

@@ -838,7 +838,14 @@ def parse_args(self):
         parser.add_argument("--no-acp", action="store_true", help="Disable ACP tools (agentic file operations with plan/approve/apply)")
         parser.add_argument("--no-lsp", action="store_true", help="Disable LSP tools (code intelligence: symbols, definitions, references)")
         parser.add_argument("--save", "-s", action="store_true", help="Save research output to file (output/research/)")
-        parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose output for research")
+        parser.add_argument("-v", "--verbose", action="count", default=0,
+                          help="Increase verbosity (-v=verbose, -vv=debug)")
+        parser.add_argument("-q", "--quiet", action="count", default=0,
+                          help="Decrease verbosity (-q=quiet, -qq=silent)")
+        parser.add_argument("--output", type=str, choices=["json", "jsonl"], dest="output_format",
+                          help="Machine-readable output format (json or jsonl)")
+        parser.add_argument("--flow", action="store_true",
+                          help="Show visual agent→tool flow chart")
         parser.add_argument("--web", "--web-search", action="store_true", help="Enable native web search (OpenAI, Gemini, Anthropic, xAI, Perplexity)")
         parser.add_argument("--web-fetch", action="store_true", help="Enable web fetch to retrieve URL content (Anthropic only)")
         parser.add_argument("--prompt-caching", action="store_true", help="Enable prompt caching to reduce costs (OpenAI, Anthropic, Bedrock, Deepseek)")
@@ -954,9 +961,6 @@ def parse_args(self):
         parser.add_argument("--lsp", action="store_true", 
                           help="Enable LSP tools in autonomy mode (slower but provides code intelligence)")
 
-        # P3/G5: Display mode - control output verbosity
-        parser.add_argument("--display", type=str, choices=["minimal", "status", "verbose", "debug", "jsonl", "json", "flow"],
-                          default="status", help="Display mode: minimal|status|verbose|debug|jsonl|json|flow")
 
         # P8/G11: Tool timeout - prevent slow tools from blocking
         parser.add_argument("--tool-timeout", type=int, default=60,
@@ -3888,9 +3892,12 @@ def handle_direct_prompt(self, prompt):
             if autonomy_mode and autonomy_mode not in ('disable', None):
                 agent_config["autonomy"] = {"level": autonomy_mode, "enabled": True}
 
-            # Set output mode based on --verbose flag
-            # Uses consolidated 'output' param instead of deprecated 'verbose'
-            if hasattr(self, 'args') and getattr(self.args, 'verbose', False):
+            # Set SDK output preset based on verbosity flags
+            # The display dispatcher handles CLI rendering; this controls SDK-level behavior
+            v = getattr(self.args, 'verbose', 0) if hasattr(self, 'args') else 0
+            if v >= 2:
+                agent_config["output"] = "verbose"  # SDK debug-level detail
+            elif v >= 1:
                 agent_config["output"] = "verbose"
             else:
                 agent_config["output"] = "minimal"
@@ -4264,42 +4271,29 @@ def level_based_approve(function_name, arguments, risk_level):
                 else:
                     result = auto_rag.chat(prompt)
             else:
-                # Unified display mode dispatcher
-                display_mode = getattr(self.args, 'display', 'status')
+                # Resolve display mode from CLI flags
+                display_mode = self._resolve_display_mode()
 
-                # Also check Typer global state (for -o json, --quiet, etc.)
-                try:
-                    from .app import state as typer_state
-                    if typer_state.quiet:
-                        display_mode = 'minimal'
-                    elif typer_state.output_format.value == 'json':
-                        display_mode = 'json'
-                    elif typer_state.output_format.value == 'stream-json':
-                        display_mode = 'jsonl'
-                    elif typer_state.screen_reader:
-                        display_mode = 'debug'  # trace-like, no spinners
-                except (ImportError, AttributeError):
-                    pass
-                
-                # Check legacy verbose flag
-                is_verbose = agent_config.get("verbose", False)
-                if is_verbose and display_mode == 'status':
-                    display_mode = 'verbose'
+                if display_mode == 'silent':
+                    # -qq: No output at all, exit code only
+                    if hasattr(agent, 'start'):
+                        result = agent.start(prompt)
+                    else:
+                        result = agent.chat(prompt)
 
-                if display_mode == 'minimal':
-                    # Quiet: result only, no spinners
+                elif display_mode == 'quiet':
+                    # -q: Result only, no spinners or status
                     if hasattr(agent, 'start'):
                         result = agent.start(prompt)
                     else:
                         result = agent.chat(prompt)
-                    # Still print the result
                     if result is not None:
                         output = getattr(result, 'output', None) or (str(result) if result else None)
                         if output:
                             print(output)
 
                 elif display_mode == 'verbose':
-                    # SDK StatusOutput with timestamps and metrics
+                    # -v: SDK StatusOutput with timestamps and metrics
                     try:
                         from praisonaiagents.output.status import enable_status_output, disable_status_output
                         enable_status_output(show_timestamps=True, show_metrics=True)
@@ -4315,7 +4309,7 @@ def level_based_approve(function_name, arguments, risk_level):
                             result = agent.chat(prompt)
 
                 elif display_mode == 'debug':
-                    # SDK TraceOutput with markdown
+                    # -vv: SDK TraceOutput with markdown rendering
                     try:
                         from praisonaiagents.output.trace import enable_trace_output, disable_trace_output
                         enable_trace_output(use_markdown=True)
@@ -4331,7 +4325,7 @@ def level_based_approve(function_name, arguments, risk_level):
                             result = agent.chat(prompt)
 
                 elif display_mode == 'jsonl':
-                    # JSONL structured output for CI/CD
+                    # --output jsonl: JSONL structured output for CI/CD
                     from .features.display_jsonl import JsonlDisplay
                     from praisonaiagents.main import register_display_callback as _reg_cb
 
@@ -4367,7 +4361,7 @@ def level_based_approve(function_name, arguments, risk_level):
                         print(result)
 
                 elif display_mode == 'json':
-                    # JSON envelope output
+                    # --output json: JSON envelope output
                     import json as json_mod
                     start_time = time.time()
                     if hasattr(agent, 'start'):
@@ -4388,7 +4382,7 @@ def level_based_approve(function_name, arguments, risk_level):
                     print(json_mod.dumps(envelope, indent=2))
 
                 elif display_mode == 'flow':
-                    # SDK FlowDisplay - visual agent→tool chart
+                    # --flow: SDK FlowDisplay - visual agent→tool chart
                     try:
                         from praisonaiagents.flow_display import track_workflow
                         flow = track_workflow()
@@ -4405,8 +4399,21 @@ def level_based_approve(function_name, arguments, risk_level):
                             result = agent.chat(prompt)
 
                 else:
-                    # Default "status" mode - enhanced interactive display
-                    result = self._run_with_status_display(agent, prompt)
+                    # Default: SDK status output — clean inline progress
+                    # Shows: spinner + tool calls, no panels, no timestamps
+                    try:
+                        from praisonaiagents.output.status import enable_status_output, disable_status_output
+                        enable_status_output(show_timestamps=False, show_metrics=False)
+                        if hasattr(agent, 'start'):
+                            result = agent.start(prompt)
+                        else:
+                            result = agent.chat(prompt)
+                        disable_status_output()
+                    except ImportError:
+                        if hasattr(agent, 'start'):
+                            result = agent.start(prompt)
+                        else:
+                            result = agent.chat(prompt)
 
             # ===== POST-PROCESSING WITH NEW FEATURES =====
 
@@ -4590,14 +4597,60 @@ def _handle_profiled_prompt(self, prompt):
         # Return the actual result for any downstream processing
         return result.output
 
+    def _resolve_display_mode(self):
+        """Map CLI flags to a display mode string.
+        
+        Priority: --output > --flow > --display (deprecated) > -v/-q > default.
+        Returns one of: 'silent', 'quiet', 'verbose', 'debug', 'json', 'jsonl', 'flow', 'status'.
+        """
+        # Machine formats take highest priority
+        output_fmt = getattr(self.args, 'output_format', None)
+        if output_fmt:
+            return output_fmt  # "json" or "jsonl"
+        
+        # --flow is an independent feature flag
+        if getattr(self.args, 'flow', False) or getattr(self.args, 'flow_display', False):
+            return 'flow'
+        
+        # Check Typer global state (for Typer subcommands)
+        try:
+            from .app import state as typer_state
+            if typer_state.quiet:
+                return 'quiet'
+            if hasattr(typer_state, 'output_format'):
+                if typer_state.output_format.value == 'json':
+                    return 'json'
+                elif typer_state.output_format.value == 'stream-json':
+                    return 'jsonl'
+            if typer_state.screen_reader:
+                return 'verbose'  # Accessible: timestamps but no spinners
+        except (ImportError, AttributeError):
+            pass
+        
+        # Verbosity ladder: -v/-vv/-q/-qq
+        v = getattr(self.args, 'verbose', 0)
+        q = getattr(self.args, 'quiet', 0)
+        if q >= 2:
+            return 'silent'
+        if q >= 1:
+            return 'quiet'
+        if v >= 2:
+            return 'debug'
+        if v >= 1:
+            return 'verbose'
+        
+        return 'status'  # Default: Rich Live TUI
+
     def _run_with_status_display(self, agent, prompt):
         """
-        Run agent with minimal status display (spinner + tool/handoff updates).
+        Run agent with Rich Live TUI display (default CLI experience).
         
         Shows:
-        - "Generating..." with spinner while processing
+        - Spinner with emoji (🤖 thinking, ⏳ tools)
         - Real-time tool call notifications via registered callback
+        - Autonomy iteration badges
         - Agent handoff notifications
+        - Elapsed time with pause tracking during approval
         """
         import threading
         import time
@@ -4660,7 +4713,7 @@ def _run_with_status_display(self, agent, prompt):
         }
 
         # P7/G3: Get display mode for tool args/results visibility
-        display_mode = getattr(self.args, 'display', 'status')
+        display_mode = self._resolve_display_mode()
 
         # Phase 0: Smart action verb mapping for tool names
         _TOOL_VERBS = {