RouteKitAI 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

routekitai/__init__.py

@@ -1,6 +1,6 @@
 """RouteKitAI: An agent development + orchestration framework."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.1"
 
 # Import hooks first to ensure ToolFilter is defined before Agent
 from routekitai.core import (

routekitai/core/message.py

@@ -1,12 +1,12 @@
 """Message primitive for RouteKit."""
 
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, Field
 
 
-class MessageRole(str, Enum):
+class MessageRole(StrEnum):
     """Message role types."""
 
     SYSTEM = "system"

routekitai/core/policies.py

@@ -25,7 +25,8 @@ class ReActPolicy(Policy):
     Simple loop: model -> decide tool -> tool -> model -> final
     """
 
-    max_iterations: int = 10
+    def __init__(self, max_iterations: int = 10) -> None:
+        self.max_iterations = max_iterations
 
     async def plan(self, state: dict[str, Any]) -> list[Action]:
         """Plan next action in ReAct loop.
@@ -57,6 +58,7 @@ class ReActPolicy(Policy):
                 ToolAction(
                     tool_name=tc["name"],
                     tool_input=tc.get("arguments", {}),
+                    tool_call_id=tc.get("id", ""),
                 )
                 for tc in last_message.tool_calls
             ]
@@ -120,6 +122,7 @@ class FunctionCallingPolicy(Policy):
                     ToolAction(
                         tool_name=tool_name,
                         tool_input=tc.get("arguments", {}),
+                        tool_call_id=tc.get("id", ""),
                     )
                 )
 
@@ -178,6 +181,10 @@ class GraphPolicy(Policy, BaseModel):
         # Execute graph
         graph_result = await executor.execute(input_data=input_data)
 
+        # Store on runtime so callers can inspect steps and state (e.g. for logging)
+        if runtime is not None:
+            runtime._last_graph_result = graph_result
+
         # Return final output as result
         final_output = graph_result.get("state", {}).get("output") or graph_result.get(
             "state", {}
@@ -302,19 +309,18 @@ class SupervisorPolicy(Policy, BaseModel):
         if iteration >= self.max_iterations:
             return [Final(output=Message.assistant("Max iterations reached"))]
 
-        # Check if we're waiting for a sub-agent result
-        if state.get("waiting_for_subagent"):
-            # Sub-agent has completed, merge result
-            subagent_result = state.get("subagent_result")
-            if subagent_result:
-                # Create message with sub-agent result
-                result_message = Message.assistant(
-                    f"Sub-agent completed: {subagent_result.get('output', 'Task completed') if isinstance(subagent_result, dict) else str(subagent_result)}"
-                )
-                # Note: State mutations should be done via reflect(), not here
-                # But we need to signal completion, so we'll let the runtime handle it
-                # Supervisor processes the result
-                return [ModelAction(messages=[*messages, result_message])]
+        # Sub-agent just completed: finalize with its result (runtime set waiting_for_subagent=False)
+        subagent_result = state.get("subagent_result")
+        if subagent_result and not state.get("waiting_for_subagent"):
+            if isinstance(subagent_result, dict) and "output" in subagent_result:
+                content = subagent_result["output"]
+                if hasattr(content, "content"):
+                    content = content.content
+                else:
+                    content = str(content)
+            else:
+                content = str(subagent_result)
+            return [Final(output=Message.assistant(content))]
 
         # If no messages, supervisor decides which agent to use
         if not messages:

routekitai/core/policy.py

@@ -28,6 +28,9 @@ class ToolAction(Action):
     action_type: str = Field(default="tool", description="Action type")
     tool_name: str = Field(..., description="Tool name to execute")
     tool_input: dict[str, Any] = Field(..., description="Tool input arguments")
+    tool_call_id: str = Field(
+        default="", description="Tool call ID from assistant message (for API compatibility)"
+    )
 
 
 class Parallel(Action):

routekitai/core/policy_adapter.py

@@ -107,6 +107,7 @@ class PolicyAdapter(RuntimePolicy):
                         input_data={
                             "tool_name": action.tool_name,
                             "tool_args": action.tool_input,
+                            "tool_call_id": action.tool_call_id,
                         },
                     )
                 )
@@ -122,12 +123,26 @@ class PolicyAdapter(RuntimePolicy):
                                 input_data={
                                     "tool_name": sub_action.tool_name,
                                     "tool_args": sub_action.tool_input,
+                                    "tool_call_id": sub_action.tool_call_id,
                                 },
                             )
                         )
                     # Other action types in parallel not yet supported
             elif isinstance(action, Final):
-                # Final action - return empty to signal completion
-                return []
+                # Final action - return a "final" step so runtime uses this output
+                steps.append(
+                    Step(
+                        step_id=str(uuid.uuid4()),
+                        step_type="final",
+                        input_data={"output": action.output},
+                    )
+                )
+                return steps
 
         return steps
+
+    async def reflect(self, state: dict[str, Any], observation: dict[str, Any]) -> dict[str, Any]:
+        """Delegate to the underlying policy's reflect if it has one."""
+        if hasattr(self.policy, "reflect") and callable(self.policy.reflect):
+            return await self.policy.reflect(state, observation)
+        return state.copy()

routekitai/core/runtime.py

@@ -107,6 +107,8 @@ class Runtime(BaseModel):
         self._current_step: int = 0
         self._total_steps: int = 0
         self._progress_callbacks: list[Callable[[dict[str, Any]], None]] = []
+        # Last graph execution result (set by GraphPolicy for callers to inspect steps/state)
+        self._last_graph_result: dict[str, Any] | None = None
 
     def register_agent(self, agent: "Agent") -> None:
         """Register an agent with the runtime.
@@ -244,16 +246,10 @@ class Runtime(BaseModel):
             }
             trace.add_event("run_completed", {"trace_id": trace_id, "result": result_dict})
 
-            # Export trace asynchronously (fire and forget)
+            # Export trace so it is on disk before returning (needed for replay and tests)
             if exporter and self.trace_dir:
-                # Ensure directory exists before async export
                 self.trace_dir.mkdir(parents=True, exist_ok=True)
-                # Create background task for trace export
-                export_task = asyncio.create_task(exporter.export(trace))
-                # Store task reference for potential cleanup
-                # Note: Task will complete in background, errors are logged by exporter
-                # For testing, we could await here, but in production we want fire-and-forget
-                # The exporter now creates the directory itself, so this should work
+                await exporter.export(trace)
 
             return result
         except asyncio.CancelledError:
@@ -394,7 +390,13 @@ class Runtime(BaseModel):
             step_results = await self._execute_steps_parallel(steps, agent, trace)
 
             # Process step results
+            final_output_message: Message | None = None
+            last_model_response: ModelResponse | None = None
             for step_result in step_results:
+                if step_result.step_type == "final":
+                    if step_result.output_data and "output" in step_result.output_data:
+                        final_output_message = step_result.output_data["output"]
+                    break
                 if step_result.step_type == "model_call":
                     # Handle model response
                     if (
@@ -413,6 +415,11 @@ class Runtime(BaseModel):
                             if isinstance(response_data, dict)
                             else []
                         )
+                        last_model_response = ModelResponse(
+                            content=content,
+                            tool_calls=None,
+                            usage=None,
+                        )
 
                         # Create assistant message with tool calls
                         tool_calls: list[dict[str, Any]] | None = None
@@ -445,13 +452,22 @@ class Runtime(BaseModel):
                             if step_result.input_data
                             else ""
                         )
+                        tool_call_id = (
+                            step_result.input_data.get("tool_call_id", "")
+                            if step_result.input_data
+                            else ""
+                        )
                         tool_result = step_result.output_data["result"]
 
-                        # Add tool result message
+                        # Add tool result message (tool_call_id required by OpenAI API)
                         messages.append(
                             Message.tool(
                                 f"Tool {tool_name} executed",
-                                {"result": tool_result, "tool": tool_name},
+                                {
+                                    "result": tool_result,
+                                    "tool": tool_name,
+                                    "tool_call_id": tool_call_id,
+                                },
                             )
                         )
 
@@ -495,6 +511,24 @@ class Runtime(BaseModel):
                             }
                             state["waiting_for_subagent"] = False
 
+            # Let policy reflect on step results (e.g. PlanExecutePolicy updates phase/plan)
+            if (
+                last_model_response is not None
+                and hasattr(policy, "reflect")
+                and callable(policy.reflect)
+            ):
+                state.setdefault(
+                    "phase", "planning"
+                )  # so policies can detect first (planning) phase
+                observation = {"result": last_model_response}
+                reflected = await policy.reflect(state, observation)
+                if isinstance(reflected, dict):
+                    state.update(reflected)
+
+            if final_output_message is not None:
+                output_message = final_output_message
+                break
+
             iteration += 1
 
         # Finalize if we hit max iterations
@@ -509,6 +543,14 @@ class Runtime(BaseModel):
                 output_message = Message.assistant(final_response.content)
                 messages.append(output_message)
 
+        # If final output has no content (e.g. model returned empty after tool use),
+        # use the last assistant message that had content so the run result is useful.
+        if not (output_message.content or "").strip() and messages:
+            for msg in reversed(messages):
+                if msg.role == MessageRole.ASSISTANT and (msg.content or "").strip():
+                    output_message = msg
+                    break
+
         # Import here to avoid circular import
         from routekitai.core.agent import RunResult
 
@@ -600,7 +642,10 @@ class Runtime(BaseModel):
             )
 
             try:
-                if step.step_type == "model_call":
+                if step.step_type == "final":
+                    # Policy produced a final output (e.g. GraphPolicy); pass it through
+                    step.output_data = {"output": step.input_data.get("output")}
+                elif step.step_type == "model_call":
                     # Check if in replay mode
                     if self._replay_mode and self._replay_trace:
                         # Match by sequential order using step_completed events
@@ -1394,6 +1439,7 @@ class DefaultPolicy(Policy):
                         input_data={
                             "tool_name": tool_call["name"],
                             "tool_args": tool_call.get("arguments", {}),
+                            "tool_call_id": tool_call.get("id", ""),
                         },
                     )
                 )

routekitai/core/tool.py

@@ -1,7 +1,7 @@
 """Tool primitive for RouteKit."""
 
 from abc import ABC, abstractmethod
-from enum import Enum
+from enum import StrEnum
 from typing import Any, TypeVar
 
 from pydantic import BaseModel, Field, create_model
@@ -12,7 +12,7 @@ TInput = TypeVar("TInput", bound=BaseModel)
 TOutput = TypeVar("TOutput", bound=BaseModel)
 
 
-class ToolPermission(str, Enum):
+class ToolPermission(StrEnum):
     """Tool permission types."""
 
     NETWORK = "network"

routekitai/graphs/graph.py

@@ -1,13 +1,13 @@
 """Graph definition for agent orchestration."""
 
 from collections.abc import Callable
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, Field
 
 
-class NodeType(str, Enum):
+class NodeType(StrEnum):
     """Type of graph node."""
 
     MODEL = "model"  # Execute a model call

routekitai/message.py

@@ -1,12 +1,12 @@
 """Message primitive for RouteKit."""
 
-from enum import Enum
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, Field
 
 
-class MessageRole(str, Enum):
+class MessageRole(StrEnum):
     """Message role types."""
 
     USER = "user"

routekitai/providers/__init__.py

@@ -1,9 +1,11 @@
 """Model providers for RouteKit."""
 
+from routekitai.providers.anthropic import AnthropicModel
 from routekitai.providers.local import FakeModel
 from routekitai.providers.openai import OpenAIChatModel
 
 __all__ = [
+    "AnthropicModel",
     "OpenAIChatModel",
     "FakeModel",
 ]

routekitai/providers/anthropic.py

@@ -75,7 +75,11 @@ class AnthropicModel(Model):
         return self._client
 
     def _message_to_anthropic(self, message: Message) -> dict[str, Any]:
-        """Convert routkitai Message to Anthropic format."""
+        """Convert routkitai Message to Anthropic format.
+
+        Anthropic requires all messages to have non-empty content except the
+        optional final assistant message. We ensure content is never empty.
+        """
         role_map = {
             MessageRole.SYSTEM: "system",
             MessageRole.USER: "user",
@@ -84,13 +88,15 @@ class AnthropicModel(Model):
         # Anthropic doesn't support tool role messages directly
         if message.role == MessageRole.TOOL:
             # Convert tool messages to user messages with tool result
-            return {
-                "role": "user",
-                "content": f"Tool result: {message.content}",
-            }
+            content = (
+                f"Tool result: {message.content}" if message.content else "Tool result: (no output)"
+            )
+            return {"role": "user", "content": content}
+        # API rejects empty or whitespace-only content; use a non-whitespace placeholder
+        content = message.content if (message.content and message.content.strip()) else "(no text)"
         return {
             "role": role_map.get(message.role, "user"),
-            "content": message.content,
+            "content": content,
         }
 
     def _tools_to_anthropic(self, tools: list[Tool]) -> list[dict[str, Any]]:
@@ -208,9 +214,19 @@ class AnthropicModel(Model):
             )
 
         except httpx.HTTPStatusError as e:
-            raise ModelError(
-                f"Anthropic API error: {e.response.status_code} - {e.response.text}"
-            ) from e
+            msg = f"Anthropic API error: {e.response.status_code}"
+            try:
+                body = e.response.json()
+                err = body.get("error") or {}
+                if isinstance(err, dict) and err.get("message"):
+                    msg = f"{msg} - {err['message']}"
+                else:
+                    msg = f"{msg} - {e.response.text}"
+            except Exception:
+                msg = f"{msg} - {e.response.text}"
+            if e.response.status_code == 404 and "model" in msg.lower():
+                msg += " Use a model ID from https://docs.anthropic.com/en/api/models or set ANTHROPIC_MODEL."
+            raise ModelError(msg) from e
         except Exception as e:
             raise ModelError(f"Failed to call Anthropic API: {e}") from e
 

routekitai/sandbox/permissions.py

@@ -1,13 +1,13 @@
 """Permission management for tool execution."""
 
-from enum import Enum
+from enum import StrEnum
 
 from pydantic import BaseModel, Field
 
 from routekitai.core.tool import ToolPermission
 
 
-class PermissionLevel(str, Enum):
+class PermissionLevel(StrEnum):
     """Permission levels for sandbox execution."""
 
     NONE = "none"

{routekitai-0.1.0.dist-info → routekitai-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RouteKitAI
-Version: 0.1.0
+Version: 0.2.1
 Summary: An agent development + orchestration framework
 Author: Mohamed Ghassen Brahim
 License: MIT
@@ -41,6 +41,9 @@ Requires-Dist: sentence-transformers>=2.2.0; extra == "optional"
 Requires-Dist: faiss-cpu>=1.7.4; extra == "optional"
 Requires-Dist: openai>=1.0.0; extra == "optional"
 Requires-Dist: nest-asyncio>=1.5.0; extra == "optional"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.0.0; extra == "docs"
 Dynamic: license-file
 
 # RouteKitAI
@@ -60,6 +63,8 @@ Dynamic: license-file
 
 ---
 
+> **⚠️ Early stage**: RouteKitAI is still in very early development. APIs may change, and some features are experimental. Use with caution in production.
+
 RouteKitAI is a Python framework for building AI agents with **graph-based orchestration**, **built-in tracing**, and **deterministic replay**. Unlike other frameworks, RouteKitAI treats observability and testability as first-class features from day one.
 
 ## ✨ Features
@@ -195,50 +200,54 @@ asyncio.run(main())
 
 - **[Architecture Guide](docs/architecture.md)**: Deep dive into RouteKitAI's design
 - **[Security & Governance](docs/security-and-governance.md)**: Security features and best practices
-- **[API Reference](https://RouteKitAI.readthedocs.io)**: Complete API documentation (coming soon)
+- **[Full documentation](https://routekitai.readthedocs.io)**: Architecture, security, and guides (Read the Docs)
 
 ## 🎓 Examples
 
 Check out the [`examples/`](examples/) directory for complete examples:
 
-- **[Basic Agent](examples/hello_RouteKitAI.py)**: Simple agent with tools
-- **[Graph Orchestration](examples/graph_agent.py)**: Multi-agent workflow
-- **[Supervisor Pattern](examples/supervisor_agent.py)**: Supervisor delegating to sub-agents
+- **[Basic Agent](examples/basic.py)** / **[Hello RouteKit](examples/hello_routekit.py)**: Simple agent with tools
+- **[Real agent with Anthropic](examples/anthropic_agent.py)**: Live Claude agent with tool use (requires `ANTHROPIC_API_KEY`)
+- **[Graph Orchestration](examples/graph_agent.py)** / **[Graph Policy](examples/graph_policy.py)**: Multi-agent workflows
+- **[Supervisor Pattern](examples/supervisor_agent.py)** / **[Supervisor Policy](examples/supervisor_policy.py)**: Supervisor delegating to sub-agents
+- **[ReAct / Plan–Execute / Function Calling](examples/react_policy.py)**, **[Plan–Execute](examples/plan_execute_policy.py)**, **[Function Calling](examples/function_calling_policy.py)**: Policy examples
 - **[Evaluation Harness](examples/eval_regression.py)**: Testing agents with datasets
 
+Run all examples: `./scripts/run_examples.sh` (or `bash scripts/run_examples.sh`).
+
 ## 🛠️ CLI Commands
 
-RouteKitAI provides a CLI for common operations:
+RouteKitAI provides a CLI (`routekitai`) for common operations:
 
 ```bash
 # Run an agent script
-RouteKitAI run agent_script.py
+routekitai run agent_script.py
 
 # View a trace (multiple formats available)
-RouteKitAI trace <trace_id>                    # Table view (default)
-RouteKitAI trace <trace_id> --format timeline  # Timeline visualization
-RouteKitAI trace <trace_id> --format steps     # Step-by-step execution
-RouteKitAI trace <trace_id> --format json      # JSON output
-RouteKitAI trace <trace_id> --format raw       # Raw JSONL
+routekitai trace <trace_id>                    # Table view (default)
+routekitai trace <trace_id> --format timeline  # Timeline visualization
+routekitai trace <trace_id> --format steps     # Step-by-step execution
+routekitai trace <trace_id> --format json     # JSON output
+routekitai trace <trace_id> --format raw      # Raw JSONL
 
 # Analyze trace metrics
-RouteKitAI trace-analyze <trace_id>            # Performance metrics, token usage, costs
+routekitai trace-analyze <trace_id>            # Performance metrics, token usage, costs
 
 # Search traces
-RouteKitAI trace-search "error"                # Search all traces for "error"
-RouteKitAI trace-search "model" --trace-id abc # Search specific trace
-RouteKitAI trace-search "tool" --event-type tool_called  # Filter by event type
+routekitai trace-search "error"                # Search all traces for "error"
+routekitai trace-search "model" --trace-id abc # Search specific trace
+routekitai trace-search "tool" --event-type tool_called  # Filter by event type
 
 # Replay a trace
-RouteKitAI replay <trace_id> --agent my_agent
+routekitai replay <trace_id> --agent my_agent
 
 # Start web UI for trace visualization
-RouteKitAI serve                    # Start on default port 8080
-RouteKitAI serve --port 3000        # Custom port
-RouteKitAI serve --host 0.0.0.0     # Make accessible from network
+routekitai serve                    # Start on default port 8080
+routekitai serve --port 3000        # Custom port
+routekitai serve --host 0.0.0.0     # Make accessible from network
 
 # Run sanity checks
-RouteKitAI test-agent
+routekitai test-agent
 ```
 
 ## 🏗️ Core Primitives
@@ -271,7 +280,7 @@ pip install -e ".[dev]"
 pytest
 
 # Run with coverage
-pytest --cov=RouteKitAI --cov-report=html
+pytest --cov=routekitai --cov-report=html
 
 # Run specific test file
 pytest tests/test_runtime.py
@@ -284,15 +293,15 @@ pytest tests/test_runtime.py
 mypy src/
 
 # Linting
-ruff check src/
+ruff check src/ tests/ examples/
 
 # Format code
-ruff format src/
+ruff format src/ tests/ examples/
 ```
 
 ## 🤝 Contributing
 
-Contributions are welcome! Please read our contributing guidelines (coming soon) and:
+Contributions are welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) and:
 
 1. Fork the repository
 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
@@ -302,8 +311,29 @@ Contributions are welcome! Please read our contributing guidelines (coming soon)
 
 ## 📋 Requirements
 
-- Python 3.11 or higher
-- Pydantic 2.0+
+**Core (always installed):**
+
+- Python 3.11+
+- [Pydantic](https://docs.pydantic.dev/) 2.x
+- [NumPy](https://numpy.org/) 1.24+
+- [httpx](https://www.python-httpx.org/) 0.24+
+
+**Optional extras:**
+
+| Extra | Purpose |
+|-------|---------|
+| `[dev]` | CLI, tests, linting, type checking (pytest, mypy, ruff, rich, typer, safety, bandit) |
+| `[ui]` | Web UI for traces: `routekitai serve` (FastAPI, Uvicorn) |
+| `[optional]` | Vector memory, OpenAI adapter (sentence-transformers, faiss, openai, nest-asyncio) |
+| `[docs]` | Build documentation locally (MkDocs, MkDocs Material) |
+
+Examples:
+
+```bash
+pip install "RouteKitAI[dev]"       # development + CLI
+pip install "RouteKitAI[dev,ui]"    # + trace web UI
+pip install "RouteKitAI[docs]"      # build docs: mkdocs build / mkdocs serve
+```
 
 ## 📄 License
 
@@ -316,7 +346,7 @@ RouteKitAI is inspired by the need for testable, observable AI agent frameworks.
 ## 🔗 Links
 
 - **GitHub**: [https://github.com/MedGhassen/RouteKitAI](https://github.com/MedGhassen/RouteKitAI)
-- **Documentation**: [https://RouteKitAI.readthedocs.io](https://RouteKitAI.readthedocs.io) (coming soon)
+- **Documentation**: [https://routekitai.readthedocs.io](https://routekitai.readthedocs.io)
 - **Issues**: [https://github.com/MedGhassen/RouteKitAI/issues](https://github.com/MedGhassen/RouteKitAI/issues)
 
 ---

{routekitai-0.1.0.dist-info → routekitai-0.2.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-routekitai/__init__.py,sha256=n5oNaNxhqdqDFCBCLBhtG0qoNz3SCWP4l3S1ublAqVc,1091
-routekitai/message.py,sha256=HvUTT9UdOlbHwoQAX7tcWCX51GD-AGanUwsb2WwKEXM,829
+routekitai/__init__.py,sha256=155KUL2u8F-wn5wV7oT4bwzpJ84l2OWhmsU-hk-MM3A,1091
+routekitai/message.py,sha256=owTgRvHctqquWROng2w06c6sMrarKlB6avxHoPhuC3k,830
 routekitai/model.py,sha256=FfGla6Hep-L1bz-rC89leGdbtQed433FZ1yz4eF0wko,1357
 routekitai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 routekitai/tool.py,sha256=o3fOyz_iOyrbYcrc7NYrI7m7JXOLEBZ5WkaKYjsvbF8,1027
@@ -17,13 +17,13 @@ routekitai/core/agent.py,sha256=z1mkIekJ8bbWebmzNADl3vMQURXDMx82eo2O_GC-TFk,1230
 routekitai/core/errors.py,sha256=YN7uo6B7R7KRk5Lwmk4JclJNBQbKOe5YzXLQtvTLKa8,1224
 routekitai/core/hooks.py,sha256=lnp5tK_amFDUbkYWxvWnIDwQ2uI4em2Go0KLb1QtD7c,5644
 routekitai/core/memory.py,sha256=szDTIr3tCgM4aeFO19tOlGj6a8lLPBHTv4KByeUxC2k,1429
-routekitai/core/message.py,sha256=kMQIQ6GgYT5Wet7qfkVbqtQyxqCOoo-2UOSEyNVbWTw,3470
+routekitai/core/message.py,sha256=-nc3rPahQFADkeoA_Ipaq4ELPI14e23JAPIskIvM7js,3471
 routekitai/core/model.py,sha256=vghe66IRXmRO5vNtxQl_L2aVrODE_5Fyj0g_BLCaSMQ,3158
-routekitai/core/policies.py,sha256=uQYagWB3LPRiP_mE963H_o7mbt7QmAobLAH_ILIFbf4,13765
-routekitai/core/policy.py,sha256=94XiqPm2fKvW7Z8o_6YwrSQUm202kFZwXbKhKy5_PXk,2683
-routekitai/core/policy_adapter.py,sha256=Nv_gf7lo9hvOnv-ojRm6idaf-GDoju_Z6vApGTIRtqw,5130
-routekitai/core/runtime.py,sha256=nXfIbJRwDXMmi-V7PY78Pu-qMB-neato2uD79cLRrG4,59624
-routekitai/core/tool.py,sha256=lN_LtV5dHok3kokt8TUGtWhvkqVow__3JhlaGq7_fRw,4958
+routekitai/core/policies.py,sha256=uNkeArb__aJdNCmdwVa8gWDZVTbSxW-MJHFgBInQFUw,13946
+routekitai/core/policy.py,sha256=CscLNg2Z4U_XV-xC0mf7QlZN-QCJ3zewSz8uPE5NIR8,2814
+routekitai/core/policy_adapter.py,sha256=GeVVQBfd4Bo3Ijzgcq8fdn1CRtC9XOVwb7f4SkfylYY,5887
+routekitai/core/runtime.py,sha256=vOngcUlpJWq2t1ZgdJqQV2gChmlZBQtg9or6Frg3Bkk,61839
+routekitai/core/tool.py,sha256=96zHRidFV8NX9x8fWvbNyT3Up2UL-0BjaNLBl_P79_o,4959
 routekitai/core/tools.py,sha256=9jye7xa1NcJnSARRarRAIMsbF6gmyI4DlyCCv7HuRYM,5215
 routekitai/evals/__init__.py,sha256=9J7kySk46qCOApOlIMvOsPSjc3_NzvxCSuZ8-OejBNU,336
 routekitai/evals/dataset.py,sha256=yivm0NKUjV91OY1jBXdueS64CusHZWnB_f-XyVRTDNA,2512
@@ -31,7 +31,7 @@ routekitai/evals/metrics.py,sha256=_sSkQxWpXVc_cC8FFzriFyNEQce8aGbx-q5rcqkesEM,3
 routekitai/evals/runner.py,sha256=cUpGjfgQy_biq2O1mOf9mZ61jMk6Y6G6Y7Cpv6RZuzQ,6980
 routekitai/graphs/__init__.py,sha256=jCmCWWtV29uDBy47U5OrBwwie6eqMC-uS-AGrXLuonM,274
 routekitai/graphs/executors.py,sha256=1wrZ5mXUMRf6TGbvfddUUm9h8ruyNjMJB6xlZDdRxh0,18329
-routekitai/graphs/graph.py,sha256=__Jl7YYqTLRTPOLDzePJAx4aiiCGRTLp34Q-s4aQ5Xc,6301
+routekitai/graphs/graph.py,sha256=vX70acCsKWs2vv7ccuUWhqhDVB1fJ-L5tKMVhpFhQLM,6302
 routekitai/memory/__init__.py,sha256=Y4QrSbzzQuutlbfnTqOwBBp6Q0ODtcoVkvXOM6eERqk,343
 routekitai/memory/episodic.py,sha256=iGWpeWo5KikTBHhWZsk41YWuT12JJ139I7Dz54LTdhk,8166
 routekitai/memory/kv.py,sha256=3w883l7MpLmDz3VhX-fzQQXtxpZhElxgCJv3RczgzE8,785
@@ -47,18 +47,18 @@ routekitai/observability/exporters/__init__.py,sha256=g_YIeoJ_YWANEtETQgF7zEBNtW
 routekitai/observability/exporters/base.py,sha256=zhkCem3xXqKmrB38QsFaM1HAbxECPOyLoPuO5Jbd-nA,672
 routekitai/observability/exporters/jsonl.py,sha256=wBHgzfvBSksQQ_WLYXnPF9OH6_a7ldgbTlTUzTs0U7E,2621
 routekitai/observability/exporters/otel.py,sha256=Cl25rA1robwJVaOtoHRT2W3VTGvY3ibJ0eoqXQwbsb8,4249
-routekitai/providers/__init__.py,sha256=jE24VQsKG5nloM6xjdBazvptblaKRBTusTc42EW5km4,197
-routekitai/providers/anthropic.py,sha256=_Zo4tN4WQ6jZcmMD7WP4izhka4yT8qr0cnrSfApuQUM,7687
+routekitai/providers/__init__.py,sha256=-43vXwysU7NNuluD2QcmNFNmlfKMgOq_5uCnWm6ptyY,277
+routekitai/providers/anthropic.py,sha256=v8aSHz4zvCYW958tV-VjGN5joya8U4LCtSUJ86pNBfs,8634
 routekitai/providers/azure_openai.py,sha256=2iTvaLFKTseKy41E4D1EOT4NvwsxK5BSo5G0xaJjd7Y,8312
 routekitai/providers/local.py,sha256=Ii959ycdAOhnUucAlaBPCNP5YOxgFgRmuCbu_XibQwY,7693
 routekitai/providers/openai.py,sha256=ImTGXOiHyNtXUNF2tzBF4Dkv8r_aPrmQDUH6Cu7-zi4,12641
 routekitai/sandbox/__init__.py,sha256=erkRO6xnq7NcOmv_rV444IRJl0WmhRWoVX1Sx8XiqXg,352
 routekitai/sandbox/filesystem.py,sha256=5bLMhrutoJQVfOM49v1L1ykVpjFee50dERdyY4VaiGM,4744
 routekitai/sandbox/network.py,sha256=cFK--kZ88irTREWgTWhXDBDvynzq9XdHjFn_jGcF3HI,4668
-routekitai/sandbox/permissions.py,sha256=p2Kgqpe_HgfTv7_JEUVLGhFn5UbsFErkmtyzBqFucWk,2093
-routekitai-0.1.0.dist-info/licenses/LICENSE,sha256=TftL8ryIHKESApEmr5TBlRg5mengWfrzzjlr7nz46iE,1079
-routekitai-0.1.0.dist-info/METADATA,sha256=0Kf-5L9YrKiTseYOd1IJgBo3EnxbWnUQho_AhSCSPK4,10113
-routekitai-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-routekitai-0.1.0.dist-info/entry_points.txt,sha256=pHUdSYPaXtmUY5LmHWKcgh2dR-t0DRrgUZ3AO0Pk9L0,56
-routekitai-0.1.0.dist-info/top_level.txt,sha256=lbYswJspf7-baehrsDZboTTxhrabTTPf4mGYC_jXKaY,11
-routekitai-0.1.0.dist-info/RECORD,,
+routekitai/sandbox/permissions.py,sha256=5rGeF_4JcpetrsVYZuAw-S-rV5vsic1OSJAh0we-uDs,2094
+routekitai-0.2.1.dist-info/licenses/LICENSE,sha256=TftL8ryIHKESApEmr5TBlRg5mengWfrzzjlr7nz46iE,1079
+routekitai-0.2.1.dist-info/METADATA,sha256=goTgbouS7za77-MZnmXGGZWc4bSh_tmAIbzATdBbi24,11747
+routekitai-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+routekitai-0.2.1.dist-info/entry_points.txt,sha256=pHUdSYPaXtmUY5LmHWKcgh2dR-t0DRrgUZ3AO0Pk9L0,56
+routekitai-0.2.1.dist-info/top_level.txt,sha256=lbYswJspf7-baehrsDZboTTxhrabTTPf4mGYC_jXKaY,11
+routekitai-0.2.1.dist-info/RECORD,,