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

quantalogic/codeact/cli_commands/list_toolboxes.py

@@ -1,47 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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]")

quantalogic/codeact/cli_commands/uninstall_toolbox.py

@@ -1,43 +0,0 @@
-import importlib.metadata
-import subprocess
-
-import typer
-from rich.console import Console
-
-app = typer.Typer()
-
-console = Console()
-
-@app.command()
-def uninstall_toolbox(
-    toolbox_name: str = typer.Argument(..., help="Name of the toolbox or package to uninstall")
-) -> None:
-    """Uninstall a toolbox by its name or the package name that provides it."""
-    try:
-        # Get all entry points in the "quantalogic.tools" group
-        eps = importlib.metadata.entry_points(group="quantalogic.tools")
-        
-        # Step 1: Check if the input is a toolbox name (entry point name)
-        for ep in eps:
-            if ep.name == toolbox_name:
-                package_name = ep.dist.name
-                subprocess.run(["uv", "pip", "uninstall", package_name], check=True)
-                console.print(f"[green]Toolbox '{toolbox_name}' (package '{package_name}') uninstalled successfully[/green]")
-                return
-        
-        # Step 2: Check if the input is a package name providing any toolbox
-        package_eps = [ep for ep in eps if ep.dist.name == toolbox_name]
-        if package_eps:
-            subprocess.run(["uv", "pip", "uninstall", toolbox_name], check=True)
-            toolboxes = ", ".join(ep.name for ep in package_eps)
-            console.print(f"[green]Package '{toolbox_name}' providing toolbox(es) '{toolboxes}' uninstalled successfully[/green]")
-            return
-        
-        # If neither a toolbox nor a package is found
-        console.print(f"[yellow]No toolbox or package '{toolbox_name}' found to uninstall[/yellow]")
-    except subprocess.CalledProcessError as e:
-        console.print(f"[red]Failed to uninstall: {e}[/red]")
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]An error occurred: {e}[/red]")
-        raise typer.Exit(code=1)

quantalogic/codeact/config.yaml

@@ -1,21 +0,0 @@
-model: "gemini/gemini-2.0-flash"
-max_iterations: 5
-max_history_tokens: 2000
-enabled_toolboxes:
-  - math_tools
-reasoner:
-  name: "default"
-  config:
-    temperature: 0.7
-executor:
-  name: "default"
-profile: "math_expert"
-personality:
-  traits:
-    - witty
-    - helpful
-tools_config:
-  - name: math_tools
-    enabled: true
-    config:
-      precision: "high"

quantalogic/codeact/constants.py

@@ -1,9 +0,0 @@
-from pathlib import Path
-
-BASE_DIR = Path(__file__).parent
-TEMPLATE_DIR = BASE_DIR / "prompts"
-LOG_FILE = "react_agent.log"
-DEFAULT_MODEL = "gemini/gemini-2.0-flash"
-MAX_TOKENS = 4000
-MAX_GENERATE_PROGRAM_TOKENS = 1000
-MAX_HISTORY_TOKENS = 8000

quantalogic/codeact/events.py

@@ -1,85 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class Event(BaseModel):
-    event_type: str
-    timestamp: datetime = Field(default_factory=datetime.now)
-
-
-class TaskStartedEvent(Event):
-    task_description: str
-    system_prompt: str = ""  # Added for persistent context
-
-
-class ThoughtGeneratedEvent(Event):
-    step_number: int
-    thought: str
-    generation_time: float
-
-
-class ActionGeneratedEvent(Event):
-    step_number: int
-    action_code: str
-    generation_time: float
-
-
-class ActionExecutedEvent(Event):
-    step_number: int
-    result_xml: str
-    execution_time: float
-
-
-class StepCompletedEvent(Event):
-    step_number: int
-    thought: str
-    action: str
-    result: str
-    is_complete: bool
-    final_answer: str | None = None
-
-
-class ErrorOccurredEvent(Event):
-    error_message: str
-    step_number: int | None = None
-
-
-class TaskCompletedEvent(Event):
-    final_answer: str | None
-    reason: str
-
-
-class StepStartedEvent(Event):
-    step_number: int
-    system_prompt: str = ""  # Added for persistent context
-    task_description: str = ""  # Added for persistent context
-
-
-class ToolExecutionStartedEvent(Event):
-    step_number: int
-    tool_name: str
-    parameters_summary: dict
-
-
-class ToolExecutionCompletedEvent(Event):
-    step_number: int
-    tool_name: str
-    result_summary: str
-
-
-class ToolExecutionErrorEvent(Event):
-    step_number: int
-    tool_name: str
-    error: str
-
-
-class StreamTokenEvent(Event):
-    token: str
-    step_number: Optional[int] = None
-
-
-class PromptGeneratedEvent(Event):
-    step_number: int
-    prompt: str