quantalogic 0.61.3__py3-none-any.whl → 0.80__py3-none-any.whl

quantalogic/codeact/cli.py

@@ -1,232 +1,50 @@
-import asyncio
-from typing import Callable, List, Optional, Union
+"""Command-line interface entry point for Quantalogic Agent."""
+
+import importlib
+from pathlib import Path
 
 import typer
 from loguru import logger
+from rich.console import Console
 
-from quantalogic.codeact.agent import Agent  # Import only Agent from agent.py
-from quantalogic.codeact.constants import DEFAULT_MODEL, LOG_FILE
-from quantalogic.codeact.events import (  # Import events from events.py
-    ActionExecutedEvent,
-    ActionGeneratedEvent,
-    ErrorOccurredEvent,
-    StepCompletedEvent,
-    StepStartedEvent,
-    StreamTokenEvent,
-    TaskCompletedEvent,
-    TaskStartedEvent,
-    ThoughtGeneratedEvent,
-    ToolExecutionCompletedEvent,
-    ToolExecutionErrorEvent,
-    ToolExecutionStartedEvent,
-)
-from quantalogic.tools import create_tool
-
-from .tools_manager import Tool, get_default_tools
-from .utils import XMLResultHandler
+from quantalogic.codeact.plugin_manager import PluginManager
 
 app = typer.Typer(no_args_is_help=True)
-
-class ProgressMonitor:
-    """Handles progress monitoring for agent events."""
-    def __init__(self):
-        self._token_buffer = ""  # Buffer to accumulate streaming tokens
-
-    async def on_task_started(self, event: TaskStartedEvent):
-        typer.echo(typer.style(f"Task Started: {event.task_description}", fg=typer.colors.GREEN, bold=True))
-        typer.echo(f"Timestamp: {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
-        typer.echo("-" * 50)
-
-    async def on_thought_generated(self, event: ThoughtGeneratedEvent):
-        typer.echo(typer.style(f"Step {event.step_number} - Thought Generated:", fg=typer.colors.CYAN, bold=True))
-        typer.echo(f"Thought: {event.thought}")
-        typer.echo(f"Generation Time: {event.generation_time:.2f} seconds")
-        typer.echo("-" * 50)
-
-    async def on_action_generated(self, event: ActionGeneratedEvent):
-        typer.echo(typer.style(f"Step {event.step_number} - Action Generated:", fg=typer.colors.BLUE, bold=True))
-        typer.echo(f"Action Code:\n{event.action_code}")
-        typer.echo(f"Generation Time: {event.generation_time:.2f} seconds")
-        typer.echo("-" * 50)
-
-    async def on_action_executed(self, event: ActionExecutedEvent):
-        summary = XMLResultHandler.format_result_summary(event.result_xml)
-        typer.echo(typer.style(f"Step {event.step_number} - Action Executed:", fg=typer.colors.MAGENTA, bold=True))
-        typer.echo(f"Result Summary:\n{summary}")
-        typer.echo(f"Execution Time: {event.execution_time:.2f} seconds")
-        typer.echo("-" * 50)
-
-    async def on_step_completed(self, event: StepCompletedEvent):
-        typer.echo(typer.style(f"Step {event.step_number} - Completed", fg=typer.colors.YELLOW, bold=True))
-        typer.echo("-" * 50)
-
-    async def on_error_occurred(self, event: ErrorOccurredEvent):
-        typer.echo(typer.style(f"Error Occurred{' at Step ' + str(event.step_number) if event.step_number else ''}:", fg=typer.colors.RED, bold=True))
-        typer.echo(f"Message: {event.error_message}")
-        typer.echo(f"Timestamp: {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
-        typer.echo("-" * 50)
-
-    async def on_task_completed(self, event: TaskCompletedEvent):
-        if event.final_answer:
-            typer.echo(typer.style("Task Completed Successfully:", fg=typer.colors.GREEN, bold=True))
-            typer.echo(f"Final Answer:\n{event.final_answer}")
-        else:
-            typer.echo(typer.style("Task Did Not Complete Successfully:", fg=typer.colors.RED, bold=True))
-            typer.echo(f"Reason: {event.reason}")
-        typer.echo(f"Timestamp: {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
-        typer.echo("-" * 50)
-
-    async def on_step_started(self, event: StepStartedEvent):
-        typer.echo(typer.style(f"Starting Step {event.step_number}", fg=typer.colors.YELLOW, bold=True))
-        typer.echo("-" * 50)
-
-    async def on_tool_execution_started(self, event: ToolExecutionStartedEvent):
-        typer.echo(typer.style(f"Tool {event.tool_name} started execution at step {event.step_number}", fg=typer.colors.CYAN))
-        typer.echo(f"Parameters: {event.parameters_summary}")
-
-    async def on_tool_execution_completed(self, event: ToolExecutionCompletedEvent):
-        typer.echo(typer.style(f"Tool {event.tool_name} completed execution at step {event.step_number}", fg=typer.colors.GREEN))
-        typer.echo(f"Result: {event.result_summary}")
-
-    async def on_tool_execution_error(self, event: ToolExecutionErrorEvent):
-        typer.echo(typer.style(f"Tool {event.tool_name} encountered an error at step {event.step_number}", fg=typer.colors.RED))
-        typer.echo(f"Error: {event.error}")
-
-    async def on_stream_token(self, event: StreamTokenEvent):
-        """Handle streaming token events for real-time output with buffering."""
-        self._token_buffer += event.token
-        # Check for natural breakpoints to flush the buffer
-        if "\n" in event.token or event.token.strip() in [".", ";", ":", "{", "}", "]", ")"]:
-            # Print the accumulated buffer with proper formatting
-            lines = self._token_buffer.split("\n")
-            for line in lines[:-1]:  # Print all complete lines
-                if line.strip():
-                    typer.echo(f"{line}", nl=False)
-                    typer.echo("")  # Add newline after each complete line
-            # Keep the last incomplete line in the buffer
-            self._token_buffer = lines[-1]
-        # Flush buffer if it gets too long (e.g., > 100 chars)
-        if len(self._token_buffer) > 100:
-            typer.echo(f"{self._token_buffer}", nl=False)
-            self._token_buffer = ""
-
-    async def flush_buffer(self):
-        """Flush any remaining tokens in the buffer."""
-        if self._token_buffer.strip():
-            typer.echo(f"{self._token_buffer}")
-            self._token_buffer = ""
-
-    async def __call__(self, event):
-        """Dispatch events to their respective handlers."""
-        if isinstance(event, TaskStartedEvent):
-            await self.on_task_started(event)
-        elif isinstance(event, ThoughtGeneratedEvent):
-            await self.on_thought_generated(event)
-        elif isinstance(event, ActionGeneratedEvent):
-            await self.on_action_generated(event)
-            await self.flush_buffer()  # Flush after action is fully generated
-        elif isinstance(event, ActionExecutedEvent):
-            await self.on_action_executed(event)
-        elif isinstance(event, StepCompletedEvent):
-            await self.on_step_completed(event)
-        elif isinstance(event, ErrorOccurredEvent):
-            await self.on_error_occurred(event)
-        elif isinstance(event, TaskCompletedEvent):
-            await self.on_task_completed(event)
-            await self.flush_buffer()  # Flush at task completion
-        elif isinstance(event, StepStartedEvent):
-            await self.on_step_started(event)
-        elif isinstance(event, ToolExecutionStartedEvent):
-            await self.on_tool_execution_started(event)
-        elif isinstance(event, ToolExecutionCompletedEvent):
-            await self.on_tool_execution_completed(event)
-        elif isinstance(event, ToolExecutionErrorEvent):
-            await self.on_tool_execution_error(event)
-        elif isinstance(event, StreamTokenEvent):
-            await self.on_stream_token(event)
-
-async def run_react_agent(
-    task: str,
-    model: str,
-    max_iterations: int,
-    success_criteria: Optional[str] = None,
-    tools: Optional[List[Union[Tool, Callable]]] = None,
-    personality: Optional[str] = None,
-    backstory: Optional[str] = None,
-    sop: Optional[str] = None,
-    debug: bool = False,
-    streaming: bool = False  # New parameter for enabling streaming
-) -> None:
-    """Run the Agent with detailed event monitoring."""
-    # Configure logging: disable stderr output unless debug is enabled
-    logger.remove()  # Remove default handler
-    if debug:
-        logger.add(typer.stderr, level="INFO")
-    logger.add(LOG_FILE, level="INFO")  # Always log to file
-
-    tools = tools if tools is not None else get_default_tools(model)
-    
-    processed_tools = []
-    for tool in tools:
-        if isinstance(tool, Tool):
-            processed_tools.append(tool)
-        elif callable(tool):
-            processed_tools.append(create_tool(tool))
-        else:
-            logger.warning(f"Invalid tool type: {type(tool)}. Skipping.")
-            typer.echo(typer.style(f"Warning: Invalid tool type {type(tool)} skipped.", fg=typer.colors.YELLOW))
-
-    agent = Agent(
-        model=model,
-        tools=processed_tools,
-        max_iterations=max_iterations,
-        personality=personality,
-        backstory=backstory,
-        sop=sop
-    )
-    
-    progress_monitor = ProgressMonitor()
-    # Use solve with tools enabled for multi-step tasks
-    solve_agent = agent  # Store reference to add observer
-    solve_agent.add_observer(progress_monitor, [
-        "TaskStarted", "ThoughtGenerated", "ActionGenerated", "ActionExecuted",
-        "StepCompleted", "ErrorOccurred", "TaskCompleted", "StepStarted",
-        "ToolExecutionStarted", "ToolExecutionCompleted", "ToolExecutionError",
-        "StreamToken"  # Added to observe streaming tokens
-    ])
-    
-    typer.echo(typer.style(f"Starting task: {task}", fg=typer.colors.GREEN, bold=True))
-    # Pass the streaming flag to the solve method
-    history = await agent.solve(task, success_criteria, streaming=streaming)
-
-@app.command()
-def react(
-    task: str = typer.Argument(..., help="The task to solve"),
-    model: str = typer.Option(DEFAULT_MODEL, help="The litellm model to use"),
-    max_iterations: int = typer.Option(5, help="Maximum reasoning steps"),
-    success_criteria: Optional[str] = typer.Option(None, help="Optional criteria to determine task completion"),
-    personality: Optional[str] = typer.Option(None, help="Agent personality (e.g., 'witty')"),
-    backstory: Optional[str] = typer.Option(None, help="Agent backstory"),
-    sop: Optional[str] = typer.Option(None, help="Standard operating procedure"),
-    debug: bool = typer.Option(False, help="Enable debug logging to stderr"),
-    streaming: bool = typer.Option(False, help="Enable streaming output for real-time token generation")
-) -> None:
-    """CLI command to run the Agent with detailed event monitoring."""
-    try:
-        asyncio.run(run_react_agent(
-            task, model, max_iterations, success_criteria,
-            personality=personality, backstory=backstory, sop=sop, debug=debug,
-            streaming=streaming  # Pass the streaming flag
-        ))
-    except Exception as e:
-        logger.error(f"Agent failed: {e}")
-        typer.echo(typer.style(f"Error: {e}", fg=typer.colors.RED))
-        raise typer.Exit(code=1)
+console = Console()
+
+# Initialize PluginManager at module level to avoid duplicate loading
+plugin_manager = PluginManager()
+plugin_manager.load_plugins()  # This is now synchronous
+
+# Dynamically load CLI commands from cli_commands directory
+cli_commands_dir = Path(__file__).parent / "cli_commands"
+for file in cli_commands_dir.glob("*.py"):
+    if file.stem != "__init__":
+        module_name = f"quantalogic.codeact.cli_commands.{file.stem}"
+        try:
+            module = importlib.import_module(module_name)
+            command_name = file.stem.replace("_", "-")
+            # Handle Typer app instances (e.g., list_toolboxes.py)
+            if hasattr(module, "app") and isinstance(module.app, typer.Typer):
+                if len(module.app.registered_commands) == 1:
+                    # If there's exactly one command, register it directly
+                    command = module.app.registered_commands[0]
+                    app.command(name=command_name)(command.callback)
+                    logger.debug(f"Loaded direct command: {command_name}")
+                else:
+                    # Otherwise, treat it as a subcommand group
+                    app.add_typer(module.app, name=command_name)
+                    logger.debug(f"Loaded command group: {command_name}")
+            # Handle direct function commands (e.g., task.py)
+            elif hasattr(module, file.stem) and callable(getattr(module, file.stem)):
+                app.command(name=command_name)(getattr(module, file.stem))
+                logger.debug(f"Loaded direct command: {command_name}")
+        except ImportError as e:
+            logger.error(f"Failed to load command module {module_name}: {e}")
+
+# Load plugin CLI commands dynamically using the module-level plugin_manager
+for cmd_name, cmd_func in plugin_manager.cli_commands.items():
+    app.command(name=cmd_name)(cmd_func)
 
 if __name__ == "__main__":
-    app()
-
-
-# Example how to use the CLI
-# python -m quantalogic.codeact.cli "Write a poem, then evaluate the quality, in French, afficher le poem et la critique. Tout doit être Français. Si le poême n'est pas de bonne qualité, ré-écrit le poême"    --streaming
-
+    app()

quantalogic/codeact/cli_commands/create_toolbox.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+from loguru import logger
+from rich.console import Console
+
+app = typer.Typer()
+
+console = Console()
+
+@app.command()
+def create_toolbox(
+    name: str = typer.Argument(..., help="Name of the new toolbox (e.g., 'my-toolbox')")
+) -> None:
+    """Create a starter toolbox project with the given name using Jinja2 templates."""
+    toolbox_dir = Path(name)
+    if toolbox_dir.exists():
+        logger.error(f"Directory '{name}' already exists.")
+        console.print(f"[red]Error: Directory '{name}' already exists.[/red]")
+        raise typer.Exit(code=1)
+
+    # Set up Jinja2 environment
+    template_dir = Path(__file__).parent.parent / "templates" / "toolbox"
+    env = Environment(loader=FileSystemLoader(template_dir), trim_blocks=True, lstrip_blocks=True)
+
+    # Create directory structure
+    toolbox_dir.mkdir()
+    package_name = name.replace("-", "_")
+    package_dir = toolbox_dir / package_name
+    package_dir.mkdir()
+    (package_dir / "__init__.py").touch()
+
+    # Render and write template files
+    context = {"name": name, "package_name": package_name}
+    for template_name in ["pyproject.toml.j2", "tools.py.j2", "README.md.j2"]:
+        template = env.get_template(template_name)
+        content = template.render(**context)
+        output_file = toolbox_dir / template_name.replace(".j2", "")
+        if template_name == "tools.py.j2":
+            output_file = package_dir / "tools.py"
+        output_file.write_text(content.strip())
+
+    logger.info(f"Created starter toolbox project: {name}")
+    console.print(f"[green]Created starter toolbox project: {name}[/green]")

quantalogic/codeact/cli_commands/install_toolbox.py

@@ -0,0 +1,20 @@
+import subprocess
+
+import typer
+from rich.console import Console
+
+app = typer.Typer()
+
+console = Console()
+
+@app.command()
+def install_toolbox(
+    toolbox_name: str = typer.Argument(..., help="Name of the toolbox to install (PyPI package or local wheel file)")
+) -> None:
+    """Install a toolbox using uv pip install."""
+    try:
+        subprocess.run(["uv", "pip", "install", toolbox_name], check=True)
+        console.print(f"[green]Toolbox '{toolbox_name}' installed successfully[/green]")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Failed to install toolbox: {e}[/red]")
+        raise typer.Exit(code=1)

quantalogic/codeact/cli_commands/list_executor.py

@@ -0,0 +1,15 @@
+import typer
+from rich.console import Console
+
+from quantalogic.codeact.cli import plugin_manager  # Import shared plugin_manager from cli.py
+
+app = typer.Typer()
+
+console = Console()
+
+@app.command()
+def list_executors() -> None:
+    """List all available executors."""
+    console.print("[bold cyan]Available Executors:[/bold cyan]")
+    for name in plugin_manager.executors.keys():
+        console.print(f"- {name}")

quantalogic/codeact/cli_commands/list_reasoners.py

@@ -0,0 +1,15 @@
+import typer
+from rich.console import Console
+
+from quantalogic.codeact.cli import plugin_manager  # Import shared plugin_manager from cli.py
+
+app = typer.Typer()
+
+console = Console()
+
+@app.command()
+def list_reasoners() -> None:
+    """List all available reasoners."""
+    console.print("[bold cyan]Available Reasoners:[/bold cyan]")
+    for name in plugin_manager.reasoners.keys():
+        console.print(f"- {name}")

quantalogic/codeact/cli_commands/list_toolboxes.py

@@ -0,0 +1,47 @@
+import typer
+from loguru import logger
+from rich.console import Console
+
+from quantalogic.codeact.cli import plugin_manager  # Import shared plugin_manager from cli.py
+
+app = typer.Typer()
+
+console = Console()
+
+@app.command()
+def list_toolboxes(
+    detail: bool = typer.Option(False, "--detail", "-d", help="Show detailed documentation for each tool")
+) -> None:
+    """List all loaded toolboxes and their associated tools from entry points.
+    
+    When --detail flag is used, displays the full documentation for each tool using its to_docstring() method.
+    """
+    logger.debug("Listing toolboxes from entry points")
+    tools = plugin_manager.tools.get_tools()
+
+    if not tools:
+        console.print("[yellow]No toolboxes found.[/yellow]")
+    else:
+        console.print("[bold cyan]Available Toolboxes and Tools:[/bold cyan]")
+        toolbox_dict = {}
+        for tool in tools:
+            toolbox_name = tool.toolbox_name if tool.toolbox_name else 'Unknown Toolbox'
+            if toolbox_name not in toolbox_dict:
+                toolbox_dict[toolbox_name] = []
+            toolbox_dict[toolbox_name].append(tool)
+
+        for toolbox_name, tools_list in toolbox_dict.items():
+            console.print(f"[bold green]Toolbox: {toolbox_name}[/bold green]")
+            for tool in sorted(tools_list, key=lambda x: x.name):
+                if detail:
+                    # Use to_docstring() method for detailed documentation
+                    docstring = tool.to_docstring()
+                    console.print(f"  - [bold]{tool.name}[/bold]")
+                    console.print(f"    Documentation:\n    {docstring.replace('\n', '\n    ')}")
+                    console.print("")
+                else:
+                    console.print(f"  - {tool.name}")
+            console.print("")
+
+if __name__ == "__main__":
+    app()

quantalogic/codeact/cli_commands/task.py

@@ -0,0 +1,215 @@
+import asyncio
+import json
+import sys
+
+import typer
+from loguru import logger
+from rich.console import Console
+
+from quantalogic.codeact.agent import Agent, AgentConfig
+from quantalogic.codeact.constants import DEFAULT_MODEL, LOG_FILE
+from quantalogic.codeact.events import (
+    ActionExecutedEvent,
+    ActionGeneratedEvent,
+    ErrorOccurredEvent,
+    StepCompletedEvent,
+    StepStartedEvent,
+    StreamTokenEvent,
+    TaskCompletedEvent,
+    TaskStartedEvent,
+    ThoughtGeneratedEvent,
+    ToolExecutionCompletedEvent,
+    ToolExecutionErrorEvent,
+    ToolExecutionStartedEvent,
+)
+from quantalogic.codeact.tools_manager import get_default_tools
+from quantalogic.codeact.utils import process_tools
+from quantalogic.codeact.xml_utils import XMLResultHandler
+
+console = Console()
+
+class ProgressMonitor:
+    """Handles progress monitoring for agent events."""
+    def __init__(self):
+        self._token_buffer = ""
+
+    async def on_task_started(self, event: TaskStartedEvent):
+        console.print(f"[bold green]Task Started: {event.task_description}[/bold green]")
+        console.print(f"Timestamp: {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+        console.print("-" * 50)
+
+    async def on_thought_generated(self, event: ThoughtGeneratedEvent):
+        console.print(f"[bold cyan]Step {event.step_number} - Thought Generated:[/bold cyan]")
+        console.print(f"Thought: {event.thought}")
+        console.print(f"Generation Time: {event.generation_time:.2f} seconds")
+        console.print("-" * 50)
+
+    async def on_action_generated(self, event: ActionGeneratedEvent):
+        console.print(f"[bold blue]Step {event.step_number} - Action Generated:[/bold blue]")
+        console.print(f"Action Code:\n{event.action_code}")
+        console.print(f"Generation Time: {event.generation_time:.2f} seconds")
+        console.print("-" * 50)
+
+    async def on_action_executed(self, event: ActionExecutedEvent):
+        summary = XMLResultHandler.format_result_summary(event.result_xml)
+        console.print(f"[bold magenta]Step {event.step_number} - Action Executed:[/bold magenta]")
+        console.print(f"Result Summary:\n{summary}")
+        console.print(f"Execution Time: {event.execution_time:.2f} seconds")
+        console.print("-" * 50)
+
+    async def on_step_completed(self, event: StepCompletedEvent):
+        console.print(f"[bold yellow]Step {event.step_number} - Completed[/bold yellow]")
+        console.print("-" * 50)
+
+    async def on_error_occurred(self, event: ErrorOccurredEvent):
+        console.print(f"[bold red]Error Occurred{' at Step ' + str(event.step_number) if event.step_number else ''}:[/bold red]")
+        console.print(f"Message: {event.error_message}")
+        console.print(f"Timestamp: {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+        console.print("-" * 50)
+
+    async def on_task_completed(self, event: TaskCompletedEvent):
+        if event.final_answer:
+            console.print("[bold green]Task Completed Successfully:[/bold green]")
+            console.print(f"Final Answer:\n{event.final_answer}")
+        else:
+            console.print("[bold red]Task Did Not Complete Successfully:[/bold red]")
+            console.print(f"Reason: {event.reason}")
+        console.print(f"Timestamp: {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+        console.print("-" * 50)
+
+    async def on_step_started(self, event: StepStartedEvent):
+        console.print(f"[bold yellow]Starting Step {event.step_number}[/bold yellow]")
+        console.print("-" * 50)
+
+    async def on_tool_execution_started(self, event: ToolExecutionStartedEvent):
+        console.print(f"[cyan]Tool {event.tool_name} started execution at step {event.step_number}[/cyan]")
+        console.print(f"Parameters: {event.parameters_summary}")
+
+    async def on_tool_execution_completed(self, event: ToolExecutionCompletedEvent):
+        console.print(f"[green]Tool {event.tool_name} completed execution at step {event.step_number}[/green]")
+        console.print(f"Result: {event.result_summary}")
+
+    async def on_tool_execution_error(self, event: ToolExecutionErrorEvent):
+        console.print(f"[red]Tool {event.tool_name} encountered an error at step {event.step_number}[/red]")
+        console.print(f"Error: {event.error}")
+
+    async def on_stream_token(self, event: StreamTokenEvent):
+        console.print(event.token, end="")
+
+    async def flush_buffer(self):
+        pass
+
+    async def __call__(self, event):
+        if isinstance(event, TaskStartedEvent):
+            await self.on_task_started(event)
+        elif isinstance(event, ThoughtGeneratedEvent):
+            await self.on_thought_generated(event)
+        elif isinstance(event, ActionGeneratedEvent):
+            await self.on_action_generated(event)
+            await self.flush_buffer()
+        elif isinstance(event, ActionExecutedEvent):
+            await self.on_action_executed(event)
+        elif isinstance(event, StepCompletedEvent):
+            await self.on_step_completed(event)
+        elif isinstance(event, ErrorOccurredEvent):
+            await self.on_error_occurred(event)
+        elif isinstance(event, TaskCompletedEvent):
+            await self.on_task_completed(event)
+            await self.flush_buffer()
+        elif isinstance(event, StepStartedEvent):
+            await self.on_step_started(event)
+        elif isinstance(event, ToolExecutionStartedEvent):
+            await self.on_tool_execution_started(event)
+        elif isinstance(event, ToolExecutionCompletedEvent):
+            await self.on_tool_execution_completed(event)
+        elif isinstance(event, ToolExecutionErrorEvent):
+            await self.on_tool_execution_error(event)
+        elif isinstance(event, StreamTokenEvent):
+            await self.on_stream_token(event)
+
+async def run_react_agent(
+    task: str,
+    model: str,
+    max_iterations: int,
+    success_criteria: str = None,
+    tools=None,
+    personality=None,
+    backstory=None,
+    sop=None,
+    debug: bool = False,
+    streaming: bool = False,
+    reasoner_name=None,
+    executor_name=None,
+    tools_config=None,
+    profile=None,
+    customizations=None
+) -> None:
+    """Run the Agent with detailed event monitoring."""
+    logger.remove()
+    logger.add(sys.stderr, level="DEBUG" if debug else "INFO")
+    logger.add(LOG_FILE, level="DEBUG" if debug else "INFO")
+
+    tools = tools if tools is not None else get_default_tools(model, tools_config=tools_config)
+    processed_tools = process_tools(tools)
+
+    # Create AgentConfig with all parameters
+    config = AgentConfig(
+        model=model,
+        max_iterations=max_iterations,
+        tools=processed_tools,
+        personality=personality,
+        backstory=backstory,
+        sop=sop,
+        reasoner_name=reasoner_name if reasoner_name else "default",
+        executor_name=executor_name if executor_name else "default",
+        tools_config=tools_config,
+        profile=profile,
+        customizations=customizations
+    )
+    
+    agent = Agent(config=config)
+    
+    progress_monitor = ProgressMonitor()
+    solve_agent = agent
+    solve_agent.add_observer(progress_monitor, [
+        "TaskStarted", "ThoughtGenerated", "ActionGenerated", "ActionExecuted",
+        "StepCompleted", "ErrorOccurred", "TaskCompleted", "StepStarted",
+        "ToolExecutionStarted", "ToolExecutionCompleted", "ToolExecutionError",
+        "StreamToken"
+    ])
+    
+    console.print(f"[bold green]Starting task: {task}[/bold green]")
+    _history = await agent.solve(task, success_criteria, streaming=streaming,
+                                reasoner_name=reasoner_name, executor_name=executor_name)
+
+def task(
+    task: str = typer.Argument(..., help="The task to solve"),
+    model: str = typer.Option(DEFAULT_MODEL, help="The litellm model to use"),
+    max_iterations: int = typer.Option(5, help="Maximum reasoning steps"),
+    success_criteria: str = typer.Option(None, help="Optional criteria to determine task completion"),
+    personality: str = typer.Option(None, help="Agent personality (e.g., 'witty')"),
+    backstory: str = typer.Option(None, help="Agent backstory"),
+    sop: str = typer.Option(None, help="Standard operating procedure"),
+    debug: bool = typer.Option(False, help="Enable debug logging to stderr"),
+    streaming: bool = typer.Option(False, help="Enable streaming output for real-time token generation"),
+    reasoner: str = typer.Option(None, help="Name of the reasoner to use"),
+    executor: str = typer.Option(None, help="Name of the executor to use"),
+    tools_config: str = typer.Option(None, help="JSON/YAML string for tools_config"),
+    profile: str = typer.Option(None, help="Agent profile (e.g., 'math_expert')"),
+    customizations: str = typer.Option(None, help="JSON/YAML string for customizations")
+) -> None:
+    """CLI command to run the Agent with detailed event monitoring."""
+    try:
+        # Parse optional JSON/YAML strings
+        tools_config_list = json.loads(tools_config) if tools_config else None
+        customizations_dict = json.loads(customizations) if customizations else None
+        asyncio.run(run_react_agent(
+            task, model, max_iterations, success_criteria,
+            personality=personality, backstory=backstory, sop=sop, debug=debug,
+            streaming=streaming, reasoner_name=reasoner, executor_name=executor,
+            tools_config=tools_config_list, profile=profile, customizations=customizations_dict
+        ))
+    except Exception as e:
+        logger.error(f"Agent failed: {e}")
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)

quantalogic/codeact/cli_commands/tool_info.py

@@ -0,0 +1,24 @@
+import typer
+from rich.console import Console
+
+from quantalogic.codeact.cli import plugin_manager  # Import shared plugin_manager from cli.py
+
+app = typer.Typer()
+
+console = Console()
+
+@app.command()
+def tool_info(tool_name: str = typer.Argument(..., help="Name of the tool")) -> None:
+    """Display information about a specific tool."""
+    tools = plugin_manager.tools.get_tools()
+    tool = next((t for t in tools if t.name == tool_name), None)
+    if tool:
+        console.print(f"[bold green]Tool: {tool.name}[/bold green]")
+        console.print(f"Description: {tool.description}")
+        console.print(f"Toolbox: {tool.toolbox_name or 'N/A'}")
+        console.print("Arguments:")
+        for arg in tool.arguments:
+            console.print(f"  - {arg.name} ({arg.arg_type}): {arg.description} {'(required)' if arg.required else ''}")
+        console.print(f"Return Type: {tool.return_type}")
+    else:
+        console.print(f"[red]Tool '{tool_name}' not found[/red]")