alita-sdk 0.3.460__py3-none-any.whl → 0.3.461__py3-none-any.whl

alita_sdk/cli/agents.py

@@ -5,10 +5,12 @@ Provides commands to work with agents interactively or in handoff mode,
 supporting both platform agents and local agent definition files.
 """
 
+import asyncio
 import click
 import json
 import logging
 import sqlite3
+import sys
 from typing import Optional, Dict, Any, List
 from pathlib import Path
 import yaml
@@ -23,7 +25,12 @@ from rich.status import Status
 from rich.live import Live
 
 from .cli import get_client
-from .config import substitute_env_vars
+# Import from refactored modules
+from .agent_ui import print_welcome, print_help, display_output, extract_output_from_result
+from .agent_loader import load_agent_definition
+from .agent_executor import create_llm_instance, create_agent_executor, create_agent_executor_with_mcp
+from .toolkit_loader import load_toolkit_config, load_toolkit_configs
+from .callbacks import create_cli_callback, CLICallbackHandler
 
 logger = logging.getLogger(__name__)
 
@@ -31,132 +38,95 @@ logger = logging.getLogger(__name__)
 console = Console()
 
 
-def _print_banner(agent_name: str, agent_type: str = "local"):
-    """Print a nice banner for the chat session using rich."""
-    content = Text()
-    content.append("🤖  ALITA AGENT CHAT\n\n", style="bold cyan")
-    content.append(f"Agent: ", style="bold")
-    content.append(f"{agent_name}\n", style="cyan")
-    content.append(f"Type:  ", style="bold")
-    content.append(f"{agent_type}", style="cyan")
+def _load_mcp_tools(agent_def: Dict[str, Any], mcp_config_path: str) -> List[Dict[str, Any]]:
+    """Load MCP tools from agent definition with tool-level filtering.
     
-    panel = Panel(
-        content,
-        box=box.DOUBLE,
-        border_style="cyan",
-        padding=(1, 2)
-    )
-    console.print(panel)
+    Args:
+        agent_def: Agent definition dictionary containing mcps list
+        mcp_config_path: Path to mcp.json configuration file (workspace-level)
+        
+    Returns:
+        List of toolkit configurations for MCP servers
+    """
+    from .mcp_loader import load_mcp_tools
+    return load_mcp_tools(agent_def, mcp_config_path)
 
 
-def _print_help():
-    """Print help message with commands using rich table."""
-    table = Table(
-        show_header=True,
-        header_style="bold yellow",
-        border_style="yellow",
-        box=box.ROUNDED,
-        title="Commands",
-        title_style="bold yellow"
-    )
+def _setup_local_agent_executor(client, agent_def: Dict[str, Any], toolkit_config: tuple,
+                                config, model: Optional[str], temperature: Optional[float],
+                                max_tokens: Optional[int], memory, work_dir: Optional[str]):
+    """Setup local agent executor with all configurations.
     
-    table.add_column("Command", style="cyan", no_wrap=True)
-    table.add_column("Description", style="white")
-    
-    table.add_row("/clear", "Clear conversation history")
-    table.add_row("/history", "Show conversation history")
-    table.add_row("/save", "Save conversation to file")
-    table.add_row("/help", "Show this help")
-    table.add_row("exit/quit", "End conversation")
-    table.add_row("", "")
-    table.add_row("@", "Mention files")
-    table.add_row("/", "Run commands")
-    
-    console.print(table)
-
-
-def load_agent_definition(file_path: str) -> Dict[str, Any]:
-    """
-    Load agent definition from file.
-    
-    Supports:
-    - YAML files (.yaml, .yml)
-    - JSON files (.json)
-    - Markdown files with YAML frontmatter (.md)
-    
-    Args:
-        file_path: Path to agent definition file
-        
     Returns:
-        Dictionary with agent configuration
+        Tuple of (agent_executor, mcp_session_manager, llm, llm_model, filesystem_tools)
     """
-    path = Path(file_path)
+    # Load toolkit configs
+    toolkit_configs = load_toolkit_configs(agent_def, toolkit_config)
     
-    if not path.exists():
-        raise FileNotFoundError(f"Agent definition not found: {file_path}")
+    # Load MCP tools
+    mcp_toolkit_configs = _load_mcp_tools(agent_def, config.mcp_config_path)
+    toolkit_configs.extend(mcp_toolkit_configs)
     
-    content = path.read_text()
+    # Create LLM instance
+    llm, llm_model, llm_temperature, llm_max_tokens = create_llm_instance(
+        client, model, agent_def, temperature, max_tokens
+    )
     
-    # Handle markdown with YAML frontmatter
-    if path.suffix == '.md':
-        if content.startswith('---'):
-            parts = content.split('---', 2)
-            if len(parts) >= 3:
-                frontmatter = yaml.safe_load(parts[1])
-                system_prompt = parts[2].strip()
-                
-                # Apply environment variable substitution
-                system_prompt = substitute_env_vars(system_prompt)
-                
-                return {
-                    'name': frontmatter.get('name', path.stem),
-                    'description': frontmatter.get('description', ''),
-                    'system_prompt': system_prompt,
-                    'model': frontmatter.get('model'),
-                    'tools': frontmatter.get('tools', []),
-                    'temperature': frontmatter.get('temperature'),
-                    'max_tokens': frontmatter.get('max_tokens'),
-                    'toolkit_configs': frontmatter.get('toolkit_configs', []),
-                }
+    # Add filesystem tools if --dir is provided
+    filesystem_tools = None
+    if work_dir:
+        from .tools import get_filesystem_tools
+        preset = agent_def.get('filesystem_tools_preset')
+        include_tools = agent_def.get('filesystem_tools_include')
+        exclude_tools = agent_def.get('filesystem_tools_exclude')
+        filesystem_tools = get_filesystem_tools(work_dir, include_tools, exclude_tools, preset)
         
-        # Plain markdown - use content as system prompt
-        return {
-            'name': path.stem,
-            'system_prompt': substitute_env_vars(content),
-        }
+        tool_count = len(filesystem_tools)
+        access_msg = f"✓ Granted filesystem access to: {work_dir} ({tool_count} tools)"
+        if preset:
+            access_msg += f" [preset: {preset}]"
+        if include_tools:
+            access_msg += f" [include: {', '.join(include_tools)}]"
+        if exclude_tools:
+            access_msg += f" [exclude: {', '.join(exclude_tools)}]"
+        console.print(f"[dim]{access_msg}[/dim]")
     
-    # Handle YAML
-    if path.suffix in ['.yaml', '.yml']:
-        content = substitute_env_vars(content)
-        config = yaml.safe_load(content)
-        if 'system_prompt' in config:
-            config['system_prompt'] = substitute_env_vars(config['system_prompt'])
-        return config
+    # Check if we have tools
+    has_tools = bool(agent_def.get('tools') or toolkit_configs or filesystem_tools)
+    has_mcp = any(tc.get('toolkit_type') == 'mcp' for tc in toolkit_configs)
     
-    # Handle JSON
-    if path.suffix == '.json':
-        content = substitute_env_vars(content)
-        config = json.loads(content)
-        if 'system_prompt' in config:
-            config['system_prompt'] = substitute_env_vars(config['system_prompt'])
-        return config
+    if not has_tools:
+        return None, None, llm, llm_model, filesystem_tools
     
-    raise ValueError(f"Unsupported file format: {path.suffix}")
-
-
-def load_toolkit_config(file_path: str) -> Dict[str, Any]:
-    """Load toolkit configuration from JSON file with env var substitution."""
-    path = Path(file_path)
-    
-    if not path.exists():
-        raise FileNotFoundError(f"Toolkit configuration not found: {file_path}")
-    
-    with open(path) as f:
-        content = f.read()
+    # Create agent executor with or without MCP
+    mcp_session_manager = None
+    if has_mcp:
+        # Create persistent event loop for MCP tools
+        from alita_sdk.runtime.tools.llm import LLMNode
+        if not hasattr(LLMNode, '_persistent_loop') or \
+           LLMNode._persistent_loop is None or \
+           LLMNode._persistent_loop.is_closed():
+            LLMNode._persistent_loop = asyncio.new_event_loop()
+            console.print("[dim]Created persistent event loop for MCP tools[/dim]")
+        
+        # Load MCP tools using persistent loop
+        loop = LLMNode._persistent_loop
+        asyncio.set_event_loop(loop)
+        agent_executor, mcp_session_manager = loop.run_until_complete(
+            create_agent_executor_with_mcp(
+                client, agent_def, toolkit_configs,
+                llm, llm_model, llm_temperature, llm_max_tokens, memory,
+                filesystem_tools=filesystem_tools
+            )
+        )
+    else:
+        agent_executor = create_agent_executor(
+            client, agent_def, toolkit_configs,
+            llm, llm_model, llm_temperature, llm_max_tokens, memory,
+            filesystem_tools=filesystem_tools
+        )
     
-    # Apply environment variable substitution
-    content = substitute_env_vars(content)
-    return json.loads(content)
+    return agent_executor, mcp_session_manager, llm, llm_model, filesystem_tools
 
 
 def _select_agent_interactive(client, config) -> Optional[str]:
@@ -493,11 +463,16 @@ def agent_show(ctx, agent_source: str, version: Optional[str]):
 @click.option('--model', help='Override LLM model')
 @click.option('--temperature', type=float, help='Override temperature')
 @click.option('--max-tokens', type=int, help='Override max tokens')
+@click.option('--dir', 'work_dir', type=click.Path(exists=True, file_okay=False, dir_okay=True),
+              help='Grant agent filesystem access to this directory')
+@click.option('--verbose', '-v', type=click.Choice(['quiet', 'default', 'debug']), default='default',
+              help='Output verbosity level: quiet (final output only), default (tool calls + outputs), debug (all including LLM calls)')
 @click.pass_context
 def agent_chat(ctx, agent_source: Optional[str], version: Optional[str], 
                toolkit_config: tuple, thread_id: Optional[str],
                model: Optional[str], temperature: Optional[float], 
-               max_tokens: Optional[int]):
+               max_tokens: Optional[int], work_dir: Optional[str],
+               verbose: str):
     """
     Start interactive chat with an agent.
     
@@ -524,13 +499,26 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
             --toolkit-config jira-config.json \\
             --toolkit-config github-config.json
         
+        # With filesystem access
+        alita-cli agent chat my-agent --dir ./workspace
+        
         # Continue previous conversation
         alita-cli agent chat my-agent --thread-id abc123
+        
+        # Quiet mode (hide tool calls and thinking)
+        alita-cli agent chat my-agent --verbose quiet
+        
+        # Debug mode (show all including LLM calls)
+        alita-cli agent chat my-agent --verbose debug
     """
     formatter = ctx.obj['formatter']
     config = ctx.obj['config']
     client = get_client(ctx)
     
+    # Setup verbose level
+    show_verbose = verbose != 'quiet'
+    debug_mode = verbose == 'debug'
+    
     try:
         # If no agent specified, show selection menu
         if not agent_source:
@@ -563,9 +551,8 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
             agent_name = agent['name']
             agent_type = "Platform Agent"
         
-        # Print nice banner
-        _print_banner(agent_name, agent_type)
-        _print_help()
+        # Print nice welcome banner
+        print_welcome(agent_name, agent_type)
         
         # Initialize conversation
         chat_history = []
@@ -574,72 +561,25 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
         from langgraph.checkpoint.sqlite import SqliteSaver
         memory = SqliteSaver(sqlite3.connect(":memory:", check_same_thread=False))
         
-        # Load toolkits if provided
-        toolkit_configs = []
-        
-        # First load from agent definition if local
-        if is_local and 'toolkit_configs' in agent_def:
-            for tk_config in agent_def['toolkit_configs']:
-                if isinstance(tk_config, dict):
-                    if 'file' in tk_config:
-                        # Load from file
-                        config = load_toolkit_config(tk_config['file'])
-                        toolkit_configs.append(config)
-                        console.print(f"[dim]Loaded toolkit config from agent definition: {tk_config['file']}[/dim]")
-                    elif 'config' in tk_config:
-                        # Inline config
-                        toolkit_configs.append(tk_config['config'])
-                        console.print(f"[dim]Loaded inline toolkit config: {tk_config['config'].get('toolkit_name', 'unknown')}[/dim]")
-        
-        # Then load from --toolkit-config options
-        if toolkit_config:
-            for config_path in toolkit_config:
-                config = load_toolkit_config(config_path)
-                toolkit_configs.append(config)
-                console.print(f"[dim]Loaded toolkit config: {config_path}[/dim]")
-        
-        # Auto-add toolkits to tools if not already present
-        if is_local and toolkit_configs:
-            tools = agent_def.get('tools', [])
-            for tk_config in toolkit_configs:
-                toolkit_name = tk_config.get('toolkit_name')
-                if toolkit_name and toolkit_name not in tools:
-                    tools.append(toolkit_name)
-                    console.print(f"[dim]Auto-added toolkit to tools: {toolkit_name}[/dim]")
-            agent_def['tools'] = tools
-        
         # Create agent executor
         if is_local:
-            # For local agents, use direct LLM integration
-            llm_model = model or agent_def.get('model', 'gpt-4o')
-            llm_temperature = temperature if temperature is not None else agent_def.get('temperature', 0.7)
-            llm_max_tokens = max_tokens or agent_def.get('max_tokens', 2000)
-            
-            system_prompt = agent_def.get('system_prompt', '')
-            
             # Display configuration
+            llm_model_display = model or agent_def.get('model', 'gpt-4o')
+            llm_temperature_display = temperature if temperature is not None else agent_def.get('temperature', 0.7)
             console.print()
-            console.print(f"✓ [green]Using model:[/green] [bold]{llm_model}[/bold]")
-            console.print(f"✓ [green]Temperature:[/green] [bold]{llm_temperature}[/bold]")
+            console.print(f"✓ [green]Using model:[/green] [bold]{llm_model_display}[/bold]")
+            console.print(f"✓ [green]Temperature:[/green] [bold]{llm_temperature_display}[/bold]")
             if agent_def.get('tools'):
                 console.print(f"✓ [green]Tools:[/green] [bold]{', '.join(agent_def['tools'])}[/bold]")
             console.print()
             
-            # Create LLM instance using AlitaClient
+            # Setup local agent executor (handles all config, tools, MCP, etc.)
             try:
-                llm = client.get_llm(
-                    model_name=llm_model,
-                    model_config={
-                        'temperature': llm_temperature,
-                        'max_tokens': llm_max_tokens
-                    }
+                agent_executor, mcp_session_manager, llm, llm_model, filesystem_tools = _setup_local_agent_executor(
+                    client, agent_def, toolkit_config, config, model, temperature, max_tokens, memory, work_dir
                 )
-            except Exception as e:
-                console.print(f"\n✗ [red]Failed to create LLM instance:[/red] {e}")
-                console.print("[yellow]Hint: Make sure OPENAI_API_KEY or other LLM credentials are set[/yellow]")
+            except Exception:
                 return
-            
-            agent_executor = None  # Local agents use direct LLM calls
         else:
             # Platform agent
             details = client.get_app_details(agent['id'])
@@ -708,12 +648,13 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
                     continue
                 
                 if user_input == '/help':
-                    _print_help()
+                    print_help()
                     continue
                 
                 # Execute agent
-                if is_local:
-                    # Local agent: use direct LLM call with streaming
+                if is_local and agent_executor is None:
+                    # Local agent without tools: use direct LLM call with streaming
+                    system_prompt = agent_def.get('system_prompt', '')
                     messages = []
                     if system_prompt:
                         messages.append({"role": "system", "content": system_prompt})
@@ -778,13 +719,37 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
                         console.print(f"\n[red]✗ Error: {e}[/red]\n")
                         continue
                 else:
-                    # Platform agent: use agent executor
-                    with console.status("[yellow]Thinking...[/yellow]", spinner="dots"):
-                        result = agent_executor.invoke({
-                            "input": [user_input],
-                            "chat_history": chat_history
-                        })
-                        output = result.get('output', '')
+                    # Agent with tools or platform agent: use agent executor
+                    # Setup callback for verbose output
+                    from langchain_core.runnables import RunnableConfig
+                    
+                    invoke_config = None
+                    if show_verbose:
+                        cli_callback = create_cli_callback(verbose=True, debug=debug_mode)
+                        invoke_config = RunnableConfig(callbacks=[cli_callback])
+                    
+                    # Show status only when not verbose (verbose shows its own progress)
+                    if not show_verbose:
+                        with console.status("[yellow]Thinking...[/yellow]", spinner="dots"):
+                            result = agent_executor.invoke(
+                                {
+                                    "input": [user_input] if not is_local else user_input,
+                                    "chat_history": chat_history
+                                },
+                                config=invoke_config
+                            )
+                    else:
+                        console.print()  # Add spacing before tool calls
+                        result = agent_executor.invoke(
+                            {
+                                "input": [user_input] if not is_local else user_input,
+                                "chat_history": chat_history
+                            },
+                            config=invoke_config
+                        )
+                        
+                    # Extract output from result
+                    output = extract_output_from_result(result)
                     
                     # Display response
                     console.print(f"\n[bold bright_cyan]{agent_name}:[/bold bright_cyan]")
@@ -828,11 +793,16 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
 @click.option('--temperature', type=float, help='Override temperature')
 @click.option('--max-tokens', type=int, help='Override max tokens')
 @click.option('--save-thread', help='Save thread ID to file for continuation')
+@click.option('--dir', 'work_dir', type=click.Path(exists=True, file_okay=False, dir_okay=True),
+              help='Grant agent filesystem access to this directory')
+@click.option('--verbose', '-v', type=click.Choice(['quiet', 'default', 'debug']), default='default',
+              help='Output verbosity level: quiet (final output only), default (tool calls + outputs), debug (all including LLM calls)')
 @click.pass_context
 def agent_run(ctx, agent_source: str, message: str, version: Optional[str],
               toolkit_config: tuple, model: Optional[str], 
               temperature: Optional[float], max_tokens: Optional[int],
-              save_thread: Optional[str]):
+              save_thread: Optional[str], work_dir: Optional[str],
+              verbose: str):
     """
     Run agent with a single message (handoff mode).
     
@@ -855,58 +825,46 @@ def agent_run(ctx, agent_source: str, message: str, version: Optional[str],
         alita-cli --output json agent run my-agent "Search for bugs" \\
             --toolkit-config jira-config.json
         
+        # With filesystem access
+        alita-cli agent run my-agent "Analyze the code in src/" --dir ./myproject
+        
         # Save thread for continuation
         alita-cli agent run my-agent "Start task" \\
             --save-thread thread.txt
+            
+        # Quiet mode (hide tool calls and thinking)
+        alita-cli agent run my-agent "Query" --verbose quiet
+        
+        # Debug mode (show all including LLM calls)
+        alita-cli agent run my-agent "Query" --verbose debug
     """
     formatter = ctx.obj['formatter']
     client = get_client(ctx)
     
+    # Setup verbose level
+    show_verbose = verbose != 'quiet'
+    debug_mode = verbose == 'debug'
+    
     try:
         # Load agent
         is_local = Path(agent_source).exists()
         
-        # Load toolkits
-        toolkit_configs = []
-        
         if is_local:
             agent_def = load_agent_definition(agent_source)
             agent_name = agent_def.get('name', Path(agent_source).stem)
             
-            # Load toolkit configs from agent definition
-            if 'toolkit_configs' in agent_def:
-                for tk_config in agent_def['toolkit_configs']:
-                    if isinstance(tk_config, dict):
-                        if 'file' in tk_config:
-                            config = load_toolkit_config(tk_config['file'])
-                            toolkit_configs.append(config)
-                        elif 'config' in tk_config:
-                            toolkit_configs.append(tk_config['config'])
-            
-            # Load additional toolkit configs from --toolkit-config options
-            if toolkit_config:
-                for config_path in toolkit_config:
-                    config = load_toolkit_config(config_path)
-                    toolkit_configs.append(config)
-            
-            # Get LLM configuration
-            llm_model = model or agent_def.get('model', 'gpt-4o')
-            llm_temperature = temperature if temperature is not None else agent_def.get('temperature', 0.7)
-            llm_max_tokens = max_tokens or agent_def.get('max_tokens', 2000)
-            system_prompt = agent_def.get('system_prompt', '')
+            # Create memory for agent
+            from langgraph.checkpoint.sqlite import SqliteSaver
+            memory = SqliteSaver(sqlite3.connect(":memory:", check_same_thread=False))
             
-            # Create LLM instance
+            # Setup local agent executor (reuses same logic as agent_chat)
             try:
-                llm = client.get_llm(
-                    model_name=llm_model,
-                    model_config={
-                        'temperature': llm_temperature,
-                        'max_tokens': llm_max_tokens
-                    }
+                agent_executor, mcp_session_manager, llm, llm_model, filesystem_tools = _setup_local_agent_executor(
+                    client, agent_def, toolkit_config, ctx.obj['config'], model, temperature, max_tokens, memory, work_dir
                 )
             except Exception as e:
                 error_panel = Panel(
-                    f"Failed to create LLM instance: {e}",
+                    f"Failed to setup agent: {e}",
                     title="Error",
                     border_style="red",
                     box=box.ROUNDED
@@ -914,44 +872,87 @@ def agent_run(ctx, agent_source: str, message: str, version: Optional[str],
                 console.print(error_panel, style="red")
                 raise click.Abort()
             
-            # Prepare messages
-            messages = []
-            if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
-            messages.append({"role": "user", "content": message})
-            
-            # Execute with spinner for non-JSON output
-            if formatter.__class__.__name__ == 'JSONFormatter':
-                response = llm.invoke(messages)
-                if hasattr(response, 'content'):
-                    output = response.content
-                else:
-                    output = str(response)
+            # Execute agent
+            if agent_executor:
+                # Setup callback for verbose output
+                from langchain_core.runnables import RunnableConfig
                 
-                click.echo(formatter._dump({
-                    'agent': agent_name,
-                    'message': message,
-                    'response': output
-                }))
+                invoke_config = None
+                if show_verbose:
+                    cli_callback = create_cli_callback(verbose=True, debug=debug_mode)
+                    invoke_config = RunnableConfig(callbacks=[cli_callback])
+                
+                # Execute with spinner for non-JSON output
+                if formatter.__class__.__name__ == 'JSONFormatter':
+                    # JSON output: always quiet, no callbacks
+                    with console.status("[yellow]Processing...[/yellow]", spinner="dots"):
+                        result = agent_executor.invoke({
+                            "input": message,
+                            "chat_history": []
+                        })
+                    
+                    click.echo(formatter._dump({
+                        'agent': agent_name,
+                        'message': message,
+                        'response': extract_output_from_result(result),
+                        'full_result': result
+                    }))
+                else:
+                    # Show status only when not verbose (verbose shows its own progress)
+                    if not show_verbose:
+                        with console.status("[yellow]Processing...[/yellow]", spinner="dots"):
+                            result = agent_executor.invoke(
+                                {
+                                    "input": message,
+                                    "chat_history": []
+                                },
+                                config=invoke_config
+                            )
+                    else:
+                        console.print()  # Add spacing before tool calls
+                        result = agent_executor.invoke(
+                            {
+                                "input": message,
+                                "chat_history": []
+                            },
+                            config=invoke_config
+                        )
+                    
+                    # Extract and display output
+                    output = extract_output_from_result(result)
+                    display_output(agent_name, message, output)
             else:
-                # Show spinner while executing
-                with console.status("[yellow]Processing...[/yellow]", spinner="dots"):
+                # Simple LLM mode without tools
+                system_prompt = agent_def.get('system_prompt', '')
+                messages = []
+                if system_prompt:
+                    messages.append({"role": "system", "content": system_prompt})
+                messages.append({"role": "user", "content": message})
+                
+                # Execute with spinner for non-JSON output
+                if formatter.__class__.__name__ == 'JSONFormatter':
                     response = llm.invoke(messages)
                     if hasattr(response, 'content'):
                         output = response.content
                     else:
                         output = str(response)
-                
-                # Format and display output
-                console.print(f"\n[bold cyan]🤖 Agent: {agent_name}[/bold cyan]\n")
-                console.print(f"[bold]Message:[/bold] {message}\n")
-                console.print("[bold]Response:[/bold]")
-                # Render markdown if the response looks like it contains markdown
-                if any(marker in output for marker in ['```', '**', '##', '- ', '* ']):
-                    console.print(Markdown(output))
+                    
+                    click.echo(formatter._dump({
+                        'agent': agent_name,
+                        'message': message,
+                        'response': output
+                    }))
                 else:
-                    console.print(output)
-                console.print()
+                    # Show spinner while executing
+                    with console.status("[yellow]Processing...[/yellow]", spinner="dots"):
+                        response = llm.invoke(messages)
+                        if hasattr(response, 'content'):
+                            output = response.content
+                        else:
+                            output = str(response)
+                    
+                    # Display output
+                    display_output(agent_name, message, output)
         
         else:
             # Platform agent
@@ -978,11 +979,11 @@ def agent_run(ctx, agent_source: str, message: str, version: Optional[str],
             else:
                 version_id = details['versions'][0]['id']
             
-            # Load additional toolkit configs from --toolkit-config options
+            # Load toolkit configs from CLI options
+            toolkit_configs = []
             if toolkit_config:
                 for config_path in toolkit_config:
-                    config = load_toolkit_config(config_path)
-                    toolkit_configs.append(config)
+                    toolkit_configs.append(load_toolkit_config(config_path))
             
             # Create memory
             from langgraph.checkpoint.sqlite import SqliteSaver
@@ -995,6 +996,14 @@ def agent_run(ctx, agent_source: str, message: str, version: Optional[str],
                 memory=memory
             )
             
+            # Setup callback for verbose output
+            from langchain_core.runnables import RunnableConfig
+            
+            invoke_config = None
+            if show_verbose:
+                cli_callback = create_cli_callback(verbose=True, debug=debug_mode)
+                invoke_config = RunnableConfig(callbacks=[cli_callback])
+            
             # Execute with spinner for non-JSON output
             if formatter.__class__.__name__ == 'JSONFormatter':
                 result = agent_executor.invoke({
@@ -1009,24 +1018,29 @@ def agent_run(ctx, agent_source: str, message: str, version: Optional[str],
                     'full_result': result
                 }))
             else:
-                # Show spinner while executing
-                with console.status("[yellow]Processing...[/yellow]", spinner="dots"):
-                    result = agent_executor.invoke({
-                        "input": [message],
-                        "chat_history": []
-                    })
+                # Show status only when not verbose
+                if not show_verbose:
+                    with console.status("[yellow]Processing...[/yellow]", spinner="dots"):
+                        result = agent_executor.invoke(
+                            {
+                                "input": [message],
+                                "chat_history": []
+                            },
+                            config=invoke_config
+                        )
+                else:
+                    console.print()  # Add spacing before tool calls
+                    result = agent_executor.invoke(
+                        {
+                            "input": [message],
+                            "chat_history": []
+                        },
+                        config=invoke_config
+                    )
                 
-                # Format and display output
-                console.print(f"\n[bold cyan]🤖 Agent: {agent['name']}[/bold cyan]\n")
-                console.print(f"[bold]Message:[/bold] {message}\n")
-                console.print("[bold]Response:[/bold]")
+                # Display output
                 response = result.get('output', 'No response')
-                # Render markdown if the response looks like it contains markdown
-                if any(marker in response for marker in ['```', '**', '##', '- ', '* ']):
-                    console.print(Markdown(response))
-                else:
-                    console.print(response)
-                console.print()
+                display_output(agent['name'], message, response)
             
             # Save thread if requested
             if save_thread: