RouteKitAI 0.1.0__py3-none-any.whl

routekitai/__init__.py

@@ -0,0 +1,53 @@
+"""RouteKitAI: An agent development + orchestration framework."""
+
+__version__ = "0.1.0"
+
+# Import hooks first to ensure ToolFilter is defined before Agent
+from routekitai.core import (
+    Agent,
+    Message,
+    MessageRole,
+    Model,
+    ModelError,
+    ModelResponse,
+    PolicyError,
+    RouteKitError,
+    RunResult,
+    Runtime,
+    StreamEvent,
+    Tool,
+    ToolCall,
+    ToolError,
+    Usage,
+)
+from routekitai.core import (
+    RuntimeError as RouteKitRuntimeError,
+)
+from routekitai.core.hooks import ToolFilter
+from routekitai.core.policies import SupervisorPolicy
+
+# Rebuild models to resolve forward references
+# Runtime needs Agent, Agent needs ToolFilter, SupervisorPolicy needs Agent
+Agent.model_rebuild()
+Runtime.model_rebuild()
+SupervisorPolicy.model_rebuild()
+
+__all__ = [
+    "Agent",
+    "Message",
+    "MessageRole",
+    "Model",
+    "ModelResponse",
+    "RouteKitError",
+    "ModelError",
+    "ToolError",
+    "PolicyError",
+    "RouteKitRuntimeError",
+    "RunResult",
+    "Runtime",
+    "StreamEvent",
+    "Tool",
+    "ToolCall",
+    "ToolFilter",
+    "Usage",
+]

routekitai/cli/__init__.py

@@ -0,0 +1,18 @@
+"""CLI tools for RouteKit."""
+
+# TODO: Implement CLI commands
+try:
+    from routekitai.cli.replay import replay_command
+    from routekitai.cli.run import run as run_command
+    from routekitai.cli.test_agent import test_command
+    from routekitai.cli.trace import trace_command
+
+    __all__ = [
+        "run_command",
+        "trace_command",
+        "replay_command",
+        "test_command",
+    ]
+except ImportError:
+    # Typer not installed, CLI not available
+    __all__ = []

routekitai/cli/main.py

@@ -0,0 +1,40 @@
+"""Main CLI entry point for RouteKit."""
+
+import sys
+
+try:
+    import typer
+except ImportError:
+    print("Error: Typer and Rich are required for CLI. Install with: pip install 'routekit[dev]'")
+    sys.exit(1)
+
+from routekitai.cli.replay import replay_command
+from routekitai.cli.run import run as run_command
+from routekitai.cli.serve import serve_command
+from routekitai.cli.test_agent import test_command
+from routekitai.cli.trace import trace_command
+from routekitai.cli.trace_analyze import analyze_command
+from routekitai.cli.trace_search import search_command
+
+app = typer.Typer(
+    name="routekit",
+    help="RouteKit: An agent development + orchestration framework",
+    add_completion=False,
+)
+
+app.command(name="run")(run_command)
+app.command(name="trace")(trace_command)
+app.command(name="trace-analyze")(analyze_command)
+app.command(name="trace-search")(search_command)
+app.command(name="serve")(serve_command)
+app.command(name="replay")(replay_command)
+app.command(name="test-agent")(test_command)
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

routekitai/cli/replay.py

@@ -0,0 +1,80 @@
+"""CLI command for replaying traces."""
+
+import asyncio
+from pathlib import Path
+
+try:
+    import typer
+    from rich.console import Console
+except ImportError as e:
+    raise ImportError("CLI dependencies not installed. Install with: pip install typer rich") from e
+
+from routekitai.core.runtime import Runtime
+from routekitai.observability.exporters.jsonl import JSONLExporter
+
+app = typer.Typer(name="replay", help="Replay agent execution traces")
+console = Console()
+
+
+def replay_command(
+    trace_id: str = typer.Argument(..., help="Trace ID to replay"),
+    agent_name: str = typer.Option(..., "--agent", "-a", help="Agent name to use for replay"),
+    trace_dir: str | None = typer.Option(
+        None, "--trace-dir", "-t", help="Directory containing trace files"
+    ),
+    verify: bool = typer.Option(
+        True, "--verify/--no-verify", help="Verify outputs match original trace"
+    ),
+) -> None:
+    """Replay a trace with deterministic execution.
+
+    Examples:
+        routkitai replay abc123 --agent my_agent
+        routkitai replay abc123 --agent my_agent --no-verify
+        routkitai replay abc123 --agent my_agent --trace-dir ./custom_traces
+    """
+
+    async def _replay() -> None:
+        # Determine trace directory
+        if trace_dir is None:
+            trace_dir_path = Path(".routekit") / "traces"
+        else:
+            trace_dir_path = Path(trace_dir)
+
+        if not trace_dir_path.exists():
+            console.print(f"[red]Error: Trace directory not found: {trace_dir_path}[/red]")
+            raise typer.Exit(1)
+
+        console.print(f"[green]Replaying trace: {trace_id}[/green]")
+        console.print(f"[dim]Agent: {agent_name}[/dim]")
+        console.print(f"[dim]Trace dir: {trace_dir_path}[/dim]\n")
+
+        # Create runtime and replay
+        runtime = Runtime(trace_dir=trace_dir_path)
+        result = await runtime.replay(trace_id, agent_name, verify_output=verify)
+
+        console.print("\n[bold]Replay completed[/bold]")
+        console.print(f"[green]Output:[/green] {result.output.content}")
+        console.print(f"[dim]Trace ID: {result.trace_id}[/dim]")
+
+        if verify:
+            # Load original trace for comparison
+            exporter = JSONLExporter(output_dir=trace_dir_path)
+            original_trace = await exporter.load(trace_id)
+            if original_trace:
+                original_completed = original_trace.get_events_by_type("run_completed")
+                if original_completed:
+                    original_result = original_completed[0].data.get("result", {})
+                    original_output = original_result.get("output", {}).get("content", "")
+                    if original_output != result.output.content:
+                        console.print("\n[yellow]⚠ Warning: Output mismatch![/yellow]")
+                        console.print(f"[dim]  Original: {original_output}[/dim]")
+                        console.print(f"[dim]  Replay:   {result.output.content}[/dim]")
+                    else:
+                        console.print("\n[green]✓ Output matches original trace[/green]")
+
+    asyncio.run(_replay())
+
+
+if __name__ == "__main__" and app is not None:
+    app()

routekitai/cli/run.py

@@ -0,0 +1,95 @@
+"""CLI command for running agents."""
+
+import asyncio
+from pathlib import Path
+
+try:
+    import typer
+    from rich.console import Console
+    from rich.markdown import Markdown
+except ImportError as e:
+    raise ImportError("CLI dependencies not installed. Install with: pip install typer rich") from e
+
+app = typer.Typer(name="run", help="Run an agent with a prompt or script")
+console = Console()
+
+
+async def _run_agent_from_script(script_path: Path) -> None:
+    """Run an agent from a Python script.
+
+    Args:
+        script_path: Path to Python script
+    """
+    import importlib.util
+    import sys
+
+    spec = importlib.util.spec_from_file_location("agent_script", script_path)
+    if spec is None or spec.loader is None:
+        console.print(f"[red]Error: Could not load script from {script_path}[/red]")
+        return
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["agent_script"] = module
+    spec.loader.exec_module(module)
+
+    # Look for a main() function or agent definition
+    if hasattr(module, "main"):
+        if asyncio.iscoroutinefunction(module.main):
+            await module.main()
+        else:
+            module.main()
+    else:
+        console.print("[yellow]Warning: No main() function found in script[/yellow]")
+
+
+@app.command()
+def run(
+    prompt_or_script: str = typer.Argument(..., help="Prompt string or path to Python script"),
+    agent_name: str = typer.Option("default", "--agent", "-a", help="Agent name (if using script)"),
+    trace_dir: str | None = typer.Option(
+        None, "--trace-dir", "-t", help="Directory for trace files"
+    ),
+    output_format: str = typer.Option("text", "--format", "-f", help="Output format: text, json"),
+) -> None:
+    """Run an agent with a prompt or execute a Python script.
+
+    Examples:
+        routkitai run "What is 2+2?"
+        routkitai run agent_script.py
+        routkitai run "Hello" --agent my_agent --format json
+    """
+
+    script_path = Path(prompt_or_script)
+    is_script = script_path.exists() and script_path.suffix == ".py"
+
+    if is_script:
+        # Run as script
+        console.print(f"[green]Running script: {script_path}[/green]")
+        asyncio.run(_run_agent_from_script(script_path))
+    else:
+        # Run as prompt (requires agent to be registered)
+        console.print("[yellow]Note: Direct prompt execution requires a registered agent.[/yellow]")
+        console.print("[yellow]Consider using a script or the Python API instead.[/yellow]")
+        console.print(f"\n[dim]Prompt: {prompt_or_script}[/dim]")
+        console.print("[dim]Agent: {agent_name}[/dim]")
+        console.print("\n[blue]Example Python usage:[/blue]")
+        console.print(
+            Markdown(
+                f"""
+```python
+from routkitai import Agent, Runtime
+from routekitai.providers.local import FakeModel
+
+model = FakeModel(name="test")
+agent = Agent(name="my_agent", model=model)
+
+result = await agent.run("{prompt_or_script}")
+print(result.output.content)
+```
+"""
+            )
+        )
+
+
+if __name__ == "__main__" and app is not None:
+    app()