RouteKitAI 0.1.0__py3-none-any.whl

routekitai/cli/test_agent.py

@@ -0,0 +1,178 @@
+"""CLI command for testing agents."""
+
+import asyncio
+from pathlib import Path
+
+try:
+    import typer
+    from rich.console import Console
+    from rich.table import Table
+except ImportError as e:
+    raise ImportError("CLI dependencies not installed. Install with: pip install typer rich") from e
+
+from routekitai.core.agent import Agent
+from routekitai.core.runtime import Runtime
+from routekitai.core.tools import EchoTool
+from routekitai.providers.local import FakeModel
+
+app = typer.Typer(name="test-agent", help="Run sanity checks on routkitai agents")
+console = Console()
+
+
+def test_command(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+) -> None:
+    """Run a battery of sanity checks on routkitai agents.
+
+    Tests basic agent functionality, tool execution, tracing, and replay.
+
+    Examples:
+        routkitai test-agent
+        routkitai test-agent --verbose
+    """
+
+    async def _run_tests() -> None:
+        console.print("[bold]Running routkitai agent sanity checks...[/bold]\n")
+
+        tests_passed = 0
+        tests_failed = 0
+        test_results = []
+
+        # Test 1: Basic agent creation
+        console.print("[cyan]Test 1: Agent creation[/cyan]")
+        try:
+            model = FakeModel(name="test")
+            model.add_response("Hello, I'm a test agent!")
+            agent = Agent(name="test_agent", model=model, tools=[EchoTool()])
+            test_results.append(("Agent creation", True, ""))
+            tests_passed += 1
+            if verbose:
+                console.print("  [green]✓[/green] Agent created successfully")
+        except Exception as e:
+            test_results.append(("Agent creation", False, str(e)))
+            tests_failed += 1
+            console.print(f"  [red]✗[/red] Failed: {e}")
+
+        # Test 2: Agent execution
+        console.print("\n[cyan]Test 2: Agent execution[/cyan]")
+        try:
+            model = FakeModel(name="test")
+            model.add_response("Test response")
+            agent = Agent(name="test_agent", model=model, tools=[])
+            result = await agent.run("Test prompt")
+            assert result.output.content == "Test response"
+            assert result.trace_id is not None
+            test_results.append(("Agent execution", True, ""))
+            tests_passed += 1
+            if verbose:
+                console.print("  [green]✓[/green] Agent executed successfully")
+                console.print(f"  [dim]    Output: {result.output.content}[/dim]")
+                console.print(f"  [dim]    Trace ID: {result.trace_id}[/dim]")
+        except Exception as e:
+            test_results.append(("Agent execution", False, str(e)))
+            tests_failed += 1
+            console.print(f"  [red]✗[/red] Failed: {e}")
+
+        # Test 3: Tool execution
+        console.print("\n[cyan]Test 3: Tool execution[/cyan]")
+        try:
+            model = FakeModel(name="test")
+            model.add_response(
+                {
+                    "content": "Calling echo",
+                    "tool_calls": [
+                        {"id": "call_1", "name": "echo", "arguments": {"message": "test"}}
+                    ],
+                }
+            )
+            model.add_response("Tool executed")
+            agent = Agent(name="test_agent", model=model, tools=[EchoTool()])
+            result = await agent.run("Use the echo tool")
+            test_results.append(("Tool execution", True, ""))
+            tests_passed += 1
+            if verbose:
+                console.print("  [green]✓[/green] Tool executed successfully")
+                console.print(f"  [dim]    Output: {result.output.content}[/dim]")
+        except Exception as e:
+            test_results.append(("Tool execution", False, str(e)))
+            tests_failed += 1
+            console.print(f"  [red]✗[/red] Failed: {e}")
+
+        # Test 4: Tracing
+        console.print("\n[cyan]Test 4: Trace generation[/cyan]")
+        try:
+            trace_dir = Path(".routekit") / "traces" / "test"
+            model = FakeModel(name="test")
+            model.add_response("Traced response")
+            agent = Agent(name="test_agent", model=model, tools=[], trace_dir=trace_dir)
+            result = await agent.run("Test trace")
+
+            # Check if trace file exists
+            from routekitai.observability.exporters.jsonl import JSONLExporter
+
+            exporter = JSONLExporter(output_dir=trace_dir)
+            trace = await exporter.load(result.trace_id)
+            assert trace is not None
+            assert len(trace.events) > 0
+            test_results.append(("Trace generation", True, ""))
+            tests_passed += 1
+            if verbose:
+                console.print("  [green]✓[/green] Trace generated successfully")
+                console.print(f"  [dim]    Events: {len(trace.events)}[/dim]")
+        except Exception as e:
+            test_results.append(("Trace generation", False, str(e)))
+            tests_failed += 1
+            console.print(f"  [red]✗[/red] Failed: {e}")
+
+        # Test 5: Replay
+        console.print("\n[cyan]Test 5: Trace replay[/cyan]")
+        try:
+            trace_dir = Path(".routekit") / "traces" / "test"
+            model = FakeModel(name="test")
+            model.add_response("Replay test")
+            agent = Agent(name="test_agent", model=model, tools=[], trace_dir=trace_dir)
+            result = await agent.run("Replay test")
+            trace_id = result.trace_id
+
+            # Replay
+            runtime = Runtime(trace_dir=trace_dir)
+            runtime.register_agent(agent)
+            replay_result = await runtime.replay(trace_id, "test_agent", verify_output=True)
+            assert replay_result.output.content == result.output.content
+            test_results.append(("Trace replay", True, ""))
+            tests_passed += 1
+            if verbose:
+                console.print("  [green]✓[/green] Replay successful")
+                console.print(
+                    f"  [dim]    Output matches: {replay_result.output.content == result.output.content}[/dim]"
+                )
+        except Exception as e:
+            test_results.append(("Trace replay", False, str(e)))
+            tests_failed += 1
+            console.print(f"  [red]✗[/red] Failed: {e}")
+
+        # Summary
+        console.print("\n" + "=" * 50)
+        table = Table(title="Test Results", show_header=True, header_style="bold magenta")
+        table.add_column("Test", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_column("Error", style="red")
+
+        for test_name, passed, error in test_results:
+            status = "[green]PASS[/green]" if passed else "[red]FAIL[/red]"
+            table.add_row(test_name, status, error or "-")
+
+        console.print(table)
+        console.print(f"\n[bold]Total: {tests_passed} passed, {tests_failed} failed[/bold]")
+
+        if tests_failed > 0:
+            console.print("\n[red]Some tests failed. Check the output above for details.[/red]")
+            raise typer.Exit(1)
+        else:
+            console.print("\n[green]All tests passed! ✓[/green]")
+
+    asyncio.run(_run_tests())
+
+
+if __name__ == "__main__" and app is not None:
+    app()

routekitai/cli/trace.py

@@ -0,0 +1,209 @@
+"""CLI command for viewing traces."""
+
+import asyncio
+import json
+from pathlib import Path
+
+try:
+    import typer
+    from rich.console import Console
+    from rich.json import JSON
+    from rich.table import Table
+except ImportError as e:
+    raise ImportError("CLI dependencies not installed. Install with: pip install typer rich") from e
+
+from routekitai.observability.analyzer import TraceAnalyzer
+from routekitai.observability.exporters.jsonl import JSONLExporter
+from routekitai.observability.trace import Trace
+
+app = typer.Typer(name="trace", help="View and inspect agent execution traces")
+console = Console()
+
+
+def trace_command(
+    trace_id: str = typer.Argument(..., help="Trace ID to view"),
+    trace_dir: str | None = typer.Option(
+        None, "--trace-dir", "-t", help="Directory containing trace files"
+    ),
+    format: str = typer.Option(
+        "table", "--format", "-f", help="Output format: table, json, raw, timeline, steps"
+    ),
+) -> None:
+    """View an agent execution trace.
+
+    Examples:
+        routkitai trace abc123
+        routkitai trace abc123 --format json
+        routkitai trace abc123 --trace-dir ./custom_traces
+    """
+    # Determine trace directory
+    trace_path: Path
+    if trace_dir is None:
+        trace_path = Path(".routekit") / "traces"
+    else:
+        trace_path = Path(trace_dir)
+
+    if not trace_path.exists():
+        console.print(f"[red]Error: Trace directory not found: {trace_dir}[/red]")
+        raise typer.Exit(1)
+
+    # Load trace
+    exporter = JSONLExporter(output_dir=trace_path)
+    trace = asyncio.run(exporter.load(trace_id))
+
+    if trace is None:
+        console.print(f"[red]Error: Trace '{trace_id}' not found in {trace_path}[/red]")
+        raise typer.Exit(1)
+
+    analyzer = TraceAnalyzer()
+
+    if format == "json":
+        # Output as JSON
+        trace_data = {
+            "trace_id": trace.trace_id,
+            "metadata": trace.metadata,
+            "events": [event.model_dump() for event in trace.events],
+        }
+        console.print(JSON(json.dumps(trace_data, indent=2)))
+    elif format == "raw":
+        # Raw JSONL output
+        trace_file = trace_path / f"{trace_id}.jsonl"
+        if trace_file.exists():
+            console.print(trace_file.read_text())
+        else:
+            console.print(f"[red]Error: Trace file not found: {trace_file}[/red]")
+    elif format == "timeline":
+        # Timeline visualization
+        _display_timeline(trace, analyzer)
+    elif format == "steps":
+        # Step-by-step execution view
+        _display_steps(trace, analyzer)
+    else:
+        # Table format (default)
+        console.print(f"\n[bold]Trace: {trace.trace_id}[/bold]")
+        if trace.metadata:
+            console.print(f"[dim]Metadata: {json.dumps(trace.metadata, indent=2)}[/dim]\n")
+
+        table = Table(title="Trace Events", show_header=True, header_style="bold magenta")
+        table.add_column("Type", style="cyan")
+        table.add_column("Timestamp", style="green")
+        table.add_column("Data", style="yellow")
+
+        for event in trace.events:
+            data_str = json.dumps(event.data, indent=2) if event.data else ""
+            # Truncate long data
+            if len(data_str) > 200:
+                data_str = data_str[:200] + "..."
+            table.add_row(event.type, f"{event.timestamp:.3f}", data_str)
+
+        console.print(table)
+        console.print(f"\n[dim]Total events: {len(trace.events)}[/dim]")
+
+        # Show quick metrics
+        metrics = analyzer.analyze(trace)
+        console.print(
+            f"\n[dim]Duration: {metrics.total_duration_ms:.2f} ms | "
+            f"Model calls: {metrics.model_calls} | "
+            f"Tool calls: {metrics.tool_calls} | "
+            f"Errors: {metrics.errors}[/dim]"
+        )
+
+
+def _display_timeline(trace: Trace, analyzer: TraceAnalyzer) -> None:
+    """Display trace as a timeline.
+
+    Args:
+        trace: Trace to display
+        analyzer: Trace analyzer instance
+    """
+    console.print(f"\n[bold cyan]Timeline: {trace.trace_id}[/bold cyan]\n")
+
+    timeline = analyzer.get_timeline(trace)
+    if not timeline:
+        console.print("[yellow]No events in trace[/yellow]")
+        return
+
+    # Create timeline visualization
+    max_time = max(entry["relative_time_ms"] for entry in timeline) if timeline else 0
+    bar_width = 60
+
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Time (ms)", style="green", width=12)
+    table.add_column("Event Type", style="cyan", width=20)
+    table.add_column("Duration (ms)", style="yellow", width=15)
+    table.add_column("Timeline", style="white", width=bar_width)
+    table.add_column("Details", style="white")
+
+    for entry in timeline:
+        event = entry["event"]
+        time_ms = entry["relative_time_ms"]
+        duration_ms = entry["duration_ms"]
+
+        # Create visual bar
+        if max_time > 0:
+            bar_pos = int((time_ms / max_time) * bar_width)
+            bar = " " * bar_pos + "█"
+        else:
+            bar = "█"
+
+        duration_str = f"{duration_ms:.2f}" if duration_ms > 0 else "-"
+        details = json.dumps(event.data, indent=2)[:100]
+        if len(json.dumps(event.data)) > 100:
+            details += "..."
+
+        table.add_row(
+            f"{time_ms:.2f}",
+            event.type,
+            duration_str,
+            bar,
+            details,
+        )
+
+    console.print(table)
+
+
+def _display_steps(trace: Trace, analyzer: TraceAnalyzer) -> None:
+    """Display step-by-step execution view.
+
+    Args:
+        trace: Trace to display
+        analyzer: Trace analyzer instance
+    """
+    console.print(f"\n[bold cyan]Step-by-Step Execution: {trace.trace_id}[/bold cyan]\n")
+
+    steps = analyzer.get_step_sequence(trace)
+    if not steps:
+        console.print("[yellow]No steps found in trace[/yellow]")
+        return
+
+    for i, step in enumerate(steps, 1):
+        step_id = step["step_id"]
+        step_type = step["step_type"]
+        duration_ms = step["duration_ms"]
+        error = step.get("error")
+
+        # Step header
+        status = "[red]✗ ERROR[/red]" if error else "[green]✓ OK[/green]"
+        console.print(f"\n[bold]Step {i}: {step_id}[/bold] ({step_type}) {status}")
+        console.print(f"[dim]Duration: {duration_ms:.2f} ms[/dim]")
+
+        if error:
+            console.print(f"[red]Error: {error}[/red]")
+
+        # Step events
+        if step["events"]:
+            event_table = Table(show_header=True, header_style="bold")
+            event_table.add_column("Event", style="cyan", width=20)
+            event_table.add_column("Data", style="white")
+
+            for event in step["events"]:
+                data_str = json.dumps(event.data, indent=2)[:200]
+                if len(json.dumps(event.data)) > 200:
+                    data_str += "..."
+                event_table.add_row(event.type, data_str)
+
+            console.print(event_table)
+
+
+if __name__ == "__main__" and app is not None:
+    app()

routekitai/cli/trace_analyze.py

@@ -0,0 +1,120 @@
+"""CLI command for trace analysis and metrics."""
+
+import asyncio
+from pathlib import Path
+
+try:
+    import typer
+    from rich.console import Console
+    from rich.table import Table
+except ImportError as e:
+    raise ImportError("CLI dependencies not installed. Install with: pip install typer rich") from e
+
+from routekitai.observability.analyzer import TraceAnalyzer
+from routekitai.observability.exporters.jsonl import JSONLExporter
+
+app = typer.Typer(name="trace-analyze", help="Analyze trace metrics and performance")
+console = Console()
+
+
+def analyze_command(
+    trace_id: str = typer.Argument(..., help="Trace ID to analyze"),
+    trace_dir: str | None = typer.Option(
+        None, "--trace-dir", "-t", help="Directory containing trace files"
+    ),
+) -> None:
+    """Analyze a trace and display metrics.
+
+    Examples:
+        routkitai trace-analyze abc123
+        routkitai trace-analyze abc123 --trace-dir ./custom_traces
+    """
+    # Determine trace directory
+    trace_path: Path
+    if trace_dir is None:
+        trace_path = Path(".routekit") / "traces"
+    else:
+        trace_path = Path(trace_dir)
+
+    if not trace_path.exists():
+        console.print(f"[red]Error: Trace directory not found: {trace_path}[/red]")
+        raise typer.Exit(1)
+
+    # Load trace
+    exporter = JSONLExporter(output_dir=trace_path)
+    trace = asyncio.run(exporter.load(trace_id))
+
+    if trace is None:
+        console.print(f"[red]Error: Trace '{trace_id}' not found in {trace_path}[/red]")
+        raise typer.Exit(1)
+
+    # Analyze trace
+    analyzer = TraceAnalyzer()
+    metrics = analyzer.analyze(trace)
+
+    # Display metrics
+    console.print(f"\n[bold cyan]Trace Analysis: {trace_id}[/bold cyan]\n")
+
+    # Overview table
+    overview_table = Table(title="Overview", show_header=True, header_style="bold magenta")
+    overview_table.add_column("Metric", style="cyan")
+    overview_table.add_column("Value", style="green")
+
+    overview_table.add_row("Total Events", str(metrics.total_events))
+    overview_table.add_row("Total Duration", f"{metrics.total_duration_ms:.2f} ms")
+    overview_table.add_row("Steps", str(metrics.steps))
+    overview_table.add_row("Errors", str(metrics.errors))
+    overview_table.add_row("Error Rate", f"{metrics.error_rate * 100:.2f}%")
+
+    console.print(overview_table)
+
+    # Model calls table
+    model_table = Table(title="Model Calls", show_header=True, header_style="bold magenta")
+    model_table.add_column("Metric", style="cyan")
+    model_table.add_column("Value", style="green")
+
+    model_table.add_row("Total Calls", str(metrics.model_calls))
+    model_table.add_row("Avg Latency", f"{metrics.avg_model_latency_ms:.2f} ms")
+    model_table.add_row("Total Tokens", str(metrics.total_tokens))
+    model_table.add_row("Prompt Tokens", str(metrics.prompt_tokens))
+    model_table.add_row("Completion Tokens", str(metrics.completion_tokens))
+
+    console.print("\n")
+    console.print(model_table)
+
+    # Tool calls table
+    tool_table = Table(title="Tool Calls", show_header=True, header_style="bold magenta")
+    tool_table.add_column("Metric", style="cyan")
+    tool_table.add_column("Value", style="green")
+
+    tool_table.add_row("Total Calls", str(metrics.tool_calls))
+    tool_table.add_row("Avg Latency", f"{metrics.avg_tool_latency_ms:.2f} ms")
+
+    console.print("\n")
+    console.print(tool_table)
+
+    # Cost estimation (if tokens available)
+    if metrics.total_tokens > 0:
+        console.print("\n[bold yellow]Cost Estimation (approximate):[/bold yellow]")
+        cost_table = Table(show_header=True, header_style="bold magenta")
+        cost_table.add_column("Provider", style="cyan")
+        cost_table.add_column("Model", style="yellow")
+        cost_table.add_column("Estimated Cost", style="green")
+
+        # OpenAI GPT-4 pricing (example)
+        gpt4_prompt_cost = (metrics.prompt_tokens / 1000) * 0.03
+        gpt4_completion_cost = (metrics.completion_tokens / 1000) * 0.06
+        cost_table.add_row("OpenAI", "gpt-4", f"${gpt4_prompt_cost + gpt4_completion_cost:.4f}")
+
+        # OpenAI GPT-3.5 pricing
+        gpt35_prompt_cost = (metrics.prompt_tokens / 1000) * 0.0015
+        gpt35_completion_cost = (metrics.completion_tokens / 1000) * 0.002
+        cost_table.add_row(
+            "OpenAI", "gpt-3.5-turbo", f"${gpt35_prompt_cost + gpt35_completion_cost:.4f}"
+        )
+
+        console.print(cost_table)
+
+
+if __name__ == "__main__" and app is not None:
+    app()

routekitai/cli/trace_search.py

@@ -0,0 +1,126 @@
+"""CLI command for searching traces."""
+
+import asyncio
+from pathlib import Path
+
+try:
+    import typer
+    from rich.console import Console
+    from rich.table import Table
+except ImportError as e:
+    raise ImportError("CLI dependencies not installed. Install with: pip install typer rich") from e
+
+from routekitai.observability.analyzer import TraceAnalyzer
+from routekitai.observability.exporters.jsonl import JSONLExporter
+
+app = typer.Typer(name="trace-search", help="Search traces by content")
+console = Console()
+
+
+def search_command(
+    query: str = typer.Argument(..., help="Search query"),
+    trace_id: str | None = typer.Option(
+        None, "--trace-id", "-t", help="Specific trace ID to search (optional)"
+    ),
+    trace_dir: str | None = typer.Option(
+        None, "--trace-dir", "-d", help="Directory containing trace files"
+    ),
+    event_type: str | None = typer.Option(None, "--event-type", "-e", help="Filter by event type"),
+) -> None:
+    """Search traces by content.
+
+    Examples:
+        routkitai trace-search "error"
+        routkitai trace-search "model" --trace-id abc123
+        routkitai trace-search "tool" --event-type tool_called
+    """
+    # Determine trace directory
+    trace_path: Path
+    if trace_dir is None:
+        trace_path = Path(".routekit") / "traces"
+    else:
+        trace_path = Path(trace_dir)
+
+    if not trace_path.exists():
+        console.print(f"[red]Error: Trace directory not found: {trace_path}[/red]")
+        raise typer.Exit(1)
+
+    exporter = JSONLExporter(output_dir=trace_path)
+    analyzer = TraceAnalyzer()
+
+    # Search in specific trace or all traces
+    if trace_id:
+        trace = asyncio.run(exporter.load(trace_id))
+        if trace is None:
+            console.print(f"[red]Error: Trace '{trace_id}' not found[/red]")
+            raise typer.Exit(1)
+
+        results = analyzer.search(trace, query)
+        if event_type:
+            results = [r for r in results if r.type == event_type]
+
+        _display_search_results(trace_id, results)
+    else:
+        # Search all traces
+        trace_files = list(trace_path.glob("*.jsonl"))
+        if not trace_files:
+            console.print(f"[yellow]No traces found in {trace_path}[/yellow]")
+            raise typer.Exit(0)
+
+        all_results: list[tuple[str, list]] = []
+        for trace_file in trace_files:
+            trace_id_from_file = trace_file.stem
+            trace = asyncio.run(exporter.load(trace_id_from_file))
+            if trace:
+                results = analyzer.search(trace, query)
+                if event_type:
+                    results = [r for r in results if r.type == event_type]
+                if results:
+                    all_results.append((trace_id_from_file, results))
+
+        if not all_results:
+            console.print(f"[yellow]No matches found for query: '{query}'[/yellow]")
+            raise typer.Exit(0)
+
+        console.print(f"\n[bold]Search Results for '{query}':[/bold]\n")
+        for tid, results in all_results:
+            console.print(f"[cyan]Trace: {tid}[/cyan] ({len(results)} matches)")
+            _display_search_results(tid, results, show_trace_id=False)
+            console.print()
+
+
+def _display_search_results(trace_id: str, results: list, show_trace_id: bool = True) -> None:
+    """Display search results in a table.
+
+    Args:
+        trace_id: Trace ID
+        results: List of matching events
+        show_trace_id: Whether to show trace ID in table
+    """
+    if not results:
+        console.print("[yellow]No matches found[/yellow]")
+        return
+
+    table = Table(show_header=True, header_style="bold magenta")
+    if show_trace_id:
+        table.add_column("Trace ID", style="cyan")
+    table.add_column("Event Type", style="yellow")
+    table.add_column("Timestamp", style="green")
+    table.add_column("Preview", style="white")
+
+    for event in results[:50]:  # Limit to 50 results
+        preview = str(event.data)[:100]
+        if len(str(event.data)) > 100:
+            preview += "..."
+        row = [event.type, f"{event.timestamp:.3f}", preview]
+        if show_trace_id:
+            row.insert(0, trace_id)
+        table.add_row(*row)
+
+    console.print(table)
+    if len(results) > 50:
+        console.print(f"[dim]... and {len(results) - 50} more results[/dim]")
+
+
+if __name__ == "__main__" and app is not None:
+    app()

routekitai/core/__init__.py

@@ -0,0 +1,58 @@
+"""routkitai core primitives."""
+
+from routekitai.core.agent import Agent, RunResult
+from routekitai.core.errors import (
+    ModelError,
+    PolicyError,
+    RouteKitError,
+    RuntimeError,
+    ToolError,
+)
+from routekitai.core.message import Message, MessageRole
+from routekitai.core.model import Model, ModelResponse, StreamEvent, ToolCall, Usage
+from routekitai.core.policies import (
+    FunctionCallingPolicy,
+    GraphPolicy,
+    PlanExecutePolicy,
+    ReActPolicy,
+    SupervisorPolicy,
+)
+from routekitai.core.policy import Action, Final, ModelAction, Parallel, Policy, ToolAction
+from routekitai.core.policy_adapter import PolicyAdapter
+from routekitai.core.runtime import Runtime
+from routekitai.core.tool import Tool
+from routekitai.core.tools import EchoTool, FileReadTool, HttpGetTool
+
+__all__ = [
+    "Action",
+    "Agent",
+    "Final",
+    "FunctionCallingPolicy",
+    "GraphPolicy",
+    "Message",
+    "MessageRole",
+    "Model",
+    "ModelAction",
+    "ModelResponse",
+    "Parallel",
+    "PlanExecutePolicy",
+    "Policy",
+    "PolicyAdapter",
+    "PolicyError",
+    "ReActPolicy",
+    "RouteKitError",
+    "ModelError",
+    "ToolError",
+    "RuntimeError",
+    "RunResult",
+    "Runtime",
+    "StreamEvent",
+    "SupervisorPolicy",
+    "Tool",
+    "ToolAction",
+    "ToolCall",
+    "Usage",
+    "EchoTool",
+    "HttpGetTool",
+    "FileReadTool",
+]