agent-runtime-core 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

agent_runtime/__init__.py

@@ -34,7 +34,7 @@ Example usage:
             return RunResult(final_output={"message": "Hello!"})
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 # Core interfaces
 from agent_runtime.interfaces import (
@@ -76,6 +76,17 @@ from agent_runtime.runner import (
     RunContextImpl,
 )
 
+
+# Testing utilities
+from agent_runtime.testing import (
+    MockRunContext,
+    MockLLMClient,
+    MockLLMResponse,
+    LLMEvaluator,
+    create_test_context,
+    run_agent_test,
+)
+
 __all__ = [
     # Version
     "__version__",
@@ -107,4 +118,11 @@ __all__ = [
     "AgentRunner",
     "RunnerConfig",
     "RunContextImpl",
+    # Testing
+    "MockRunContext",
+    "MockLLMClient",
+    "MockLLMResponse",
+    "LLMEvaluator",
+    "create_test_context",
+    "run_agent_test",
 ]

agent_runtime/testing.py

@@ -0,0 +1,358 @@
+"""
+Testing utilities for agent runtimes.
+
+This module provides tools for testing agent implementations:
+- MockRunContext: A concrete RunContext for unit tests
+- MockLLMClient: A mock LLM client with predefined responses
+- AgentTestCase: Base test class with common helpers
+- LLMEvaluator: Use LLM to evaluate agent responses
+
+Example usage:
+    from agent_runtime.testing import MockRunContext, MockLLMClient, AgentTestCase
+    
+    class TestMyAgent(AgentTestCase):
+        async def test_agent_responds(self):
+            ctx = self.create_context("Hello, agent!")
+            result = await self.agent.run(ctx)
+            self.assertIn("response", result.final_output)
+"""
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional, AsyncIterator
+from uuid import UUID, uuid4
+import json
+
+from .interfaces import (
+    AgentRuntime,
+    EventType,
+    LLMClient,
+    LLMResponse,
+    LLMStreamChunk,
+    Message,
+    RunContext,
+    RunResult,
+    Tool,
+    ToolRegistry,
+)
+
+
+@dataclass
+class MockRunContext:
+    """
+    A concrete implementation of RunContext for testing.
+    
+    Use this in unit tests to provide a context to your agent
+    without needing the full runtime infrastructure.
+    
+    Example:
+        ctx = MockRunContext(
+            input_messages=[{"role": "user", "content": "Hello"}],
+            metadata={"user_id": "123"}
+        )
+        result = await my_agent.run(ctx)
+    """
+    
+    input_messages: list[Message] = field(default_factory=list)
+    params: dict = field(default_factory=dict)
+    metadata: dict = field(default_factory=dict)
+    run_id: UUID = field(default_factory=uuid4)
+    conversation_id: Optional[UUID] = None
+    tool_registry: ToolRegistry = field(default_factory=ToolRegistry)
+    
+    # Internal state
+    _events: list[tuple[str, dict]] = field(default_factory=list)
+    _checkpoints: list[dict] = field(default_factory=list)
+    _cancelled: bool = False
+    
+    async def emit(self, event_type: EventType | str, payload: dict) -> None:
+        """Record emitted events for later inspection."""
+        event_name = event_type.value if isinstance(event_type, EventType) else event_type
+        self._events.append((event_name, payload))
+    
+    async def checkpoint(self, state: dict) -> None:
+        """Save a checkpoint."""
+        self._checkpoints.append(state)
+    
+    async def get_state(self) -> Optional[dict]:
+        """Get the last checkpoint."""
+        return self._checkpoints[-1] if self._checkpoints else None
+    
+    def cancelled(self) -> bool:
+        """Check if cancelled."""
+        return self._cancelled
+    
+    def cancel(self) -> None:
+        """Request cancellation."""
+        self._cancelled = True
+    
+    # Test helpers
+    def get_events(self, event_type: Optional[str] = None) -> list[tuple[str, dict]]:
+        """Get recorded events, optionally filtered by type."""
+        if event_type is None:
+            return self._events
+        return [(t, p) for t, p in self._events if t == event_type]
+    
+    def get_checkpoints(self) -> list[dict]:
+        """Get all checkpoints."""
+        return self._checkpoints
+    
+    def clear(self) -> None:
+        """Clear recorded events and checkpoints."""
+        self._events.clear()
+        self._checkpoints.clear()
+        self._cancelled = False
+
+
+@dataclass
+class MockLLMResponse:
+    """A predefined response for MockLLMClient."""
+    content: str
+    tool_calls: Optional[list[dict]] = None
+    finish_reason: str = "stop"
+
+
+class MockLLMClient(LLMClient):
+    """
+    A mock LLM client for testing.
+    
+    Configure with predefined responses or a response function.
+    
+    Example:
+        # Simple predefined responses
+        client = MockLLMClient(responses=[
+            MockLLMResponse(content="Hello!"),
+            MockLLMResponse(content="How can I help?"),
+        ])
+        
+        # Dynamic responses based on input
+        def respond(messages):
+            if "weather" in messages[-1]["content"].lower():
+                return MockLLMResponse(content="It's sunny!")
+            return MockLLMResponse(content="I don't know.")
+        
+        client = MockLLMClient(response_fn=respond)
+    """
+    
+    def __init__(
+        self,
+        responses: Optional[list[MockLLMResponse]] = None,
+        response_fn: Optional[Callable[[list[Message]], MockLLMResponse]] = None,
+        default_response: str = "Mock response",
+    ):
+        self._responses = responses or []
+        self._response_fn = response_fn
+        self._default_response = default_response
+        self._call_count = 0
+        self._calls: list[dict] = []
+    
+    async def generate(
+        self,
+        messages: list[Message],
+        *,
+        model: Optional[str] = None,
+        stream: bool = False,
+        tools: Optional[list[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        **kwargs,
+    ) -> LLMResponse:
+        """Generate a mock response."""
+        # Record the call
+        self._calls.append({
+            "messages": messages,
+            "model": model,
+            "tools": tools,
+            "kwargs": kwargs,
+        })
+        
+        # Get response
+        if self._response_fn:
+            mock_resp = self._response_fn(messages)
+        elif self._call_count < len(self._responses):
+            mock_resp = self._responses[self._call_count]
+        else:
+            mock_resp = MockLLMResponse(content=self._default_response)
+        
+        self._call_count += 1
+        
+        # Build message
+        message: Message = {
+            "role": "assistant",
+            "content": mock_resp.content,
+        }
+        if mock_resp.tool_calls:
+            message["tool_calls"] = mock_resp.tool_calls
+        
+        return LLMResponse(
+            message=message,
+            model=model or "mock-model",
+            finish_reason=mock_resp.finish_reason,
+            usage={"prompt_tokens": 10, "completion_tokens": 20},
+        )
+    
+    async def stream(
+        self,
+        messages: list[Message],
+        *,
+        model: Optional[str] = None,
+        tools: Optional[list[dict]] = None,
+        **kwargs,
+    ) -> AsyncIterator[LLMStreamChunk]:
+        """Stream a mock response (yields content in chunks)."""
+        response = await self.generate(messages, model=model, tools=tools, **kwargs)
+        content = response.message.get("content", "")
+        
+        # Yield content in chunks
+        for i in range(0, len(content), 10):
+            yield LLMStreamChunk(delta=content[i:i+10])
+        
+        yield LLMStreamChunk(finish_reason="stop", usage=response.usage)
+    
+    # Test helpers
+    def get_calls(self) -> list[dict]:
+        """Get all recorded calls."""
+        return self._calls
+    
+    def get_call_count(self) -> int:
+        """Get the number of calls made."""
+        return self._call_count
+    
+    def reset(self) -> None:
+        """Reset call tracking."""
+        self._call_count = 0
+        self._calls.clear()
+
+
+class LLMEvaluator:
+    """
+    Use an LLM to evaluate agent responses.
+    
+    This is useful for testing that agent responses meet certain criteria
+    without having to write brittle string matching tests.
+    
+    Example:
+        evaluator = LLMEvaluator(openai_client)
+        
+        passed, explanation = await evaluator.evaluate(
+            user_query="What's the weather?",
+            agent_response="It's currently 72°F and sunny in San Francisco.",
+            criteria="The response should include temperature and weather conditions"
+        )
+        
+        assert passed, f"Evaluation failed: {explanation}"
+    """
+    
+    def __init__(self, llm_client: LLMClient, model: str = "gpt-4o-mini"):
+        self._client = llm_client
+        self._model = model
+    
+    async def evaluate(
+        self,
+        user_query: str,
+        agent_response: str,
+        criteria: str,
+    ) -> tuple[bool, str]:
+        """
+        Evaluate an agent response against criteria.
+        
+        Args:
+            user_query: The original user query
+            agent_response: The agent's response
+            criteria: What the response should satisfy
+            
+        Returns:
+            Tuple of (passed: bool, explanation: str)
+        """
+        eval_prompt = f"""You are evaluating an AI assistant's response.
+
+User Query: {user_query}
+
+Agent Response: {agent_response}
+
+Evaluation Criteria: {criteria}
+
+Does the response meet the criteria? Answer with just "PASS" or "FAIL" followed by a brief explanation."""
+
+        response = await self._client.generate(
+            messages=[{"role": "user", "content": eval_prompt}],
+            model=self._model,
+            temperature=0,
+        )
+        
+        result = response.message.get("content", "FAIL Unknown error")
+        passed = result.strip().upper().startswith("PASS")
+        return passed, result
+    
+    async def evaluate_tool_usage(
+        self,
+        user_query: str,
+        tool_calls: list[dict],
+        expected_tools: list[str],
+    ) -> tuple[bool, str]:
+        """
+        Evaluate whether the agent used the expected tools.
+        
+        Args:
+            user_query: The original user query
+            tool_calls: List of tool calls made by the agent
+            expected_tools: List of tool names that should have been called
+            
+        Returns:
+            Tuple of (passed: bool, explanation: str)
+        """
+        tool_names = [tc.get("function", {}).get("name", tc.get("name", "unknown")) 
+                      for tc in tool_calls]
+        
+        missing = set(expected_tools) - set(tool_names)
+        if missing:
+            return False, f"Missing expected tools: {missing}. Called: {tool_names}"
+        
+        return True, f"All expected tools were called: {tool_names}"
+
+
+def create_test_context(
+    message: str,
+    *,
+    tools: Optional[list[Tool]] = None,
+    metadata: Optional[dict] = None,
+    params: Optional[dict] = None,
+) -> MockRunContext:
+    """
+    Convenience function to create a test context.
+    
+    Example:
+        ctx = create_test_context("Hello, agent!", tools=[my_tool])
+        result = await agent.run(ctx)
+    """
+    registry = ToolRegistry()
+    if tools:
+        for tool in tools:
+            registry.register(tool)
+    
+    return MockRunContext(
+        input_messages=[{"role": "user", "content": message}],
+        tool_registry=registry,
+        metadata=metadata or {},
+        params=params or {},
+    )
+
+
+async def run_agent_test(
+    agent: AgentRuntime,
+    message: str,
+    *,
+    tools: Optional[list[Tool]] = None,
+    metadata: Optional[dict] = None,
+) -> tuple[RunResult, MockRunContext]:
+    """
+    Run an agent with a test message and return both result and context.
+    
+    Example:
+        result, ctx = await run_agent_test(my_agent, "Hello!")
+        assert "greeting" in result.final_output
+        assert len(ctx.get_events()) > 0
+    """
+    ctx = create_test_context(message, tools=tools, metadata=metadata)
+    result = await agent.run(ctx)
+    return result, ctx

agent_runtime_core-0.1.2.dist-info/METADATA

@@ -0,0 +1,461 @@
+Metadata-Version: 2.4
+Name: agent-runtime-core
+Version: 0.1.2
+Summary: Framework-agnostic Python library for executing AI agents with consistent patterns
+Project-URL: Homepage, https://github.com/colstrom/agent_runtime
+Project-URL: Repository, https://github.com/colstrom/agent_runtime
+Author: Chris Olstrom
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,async,llm,runtime
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Provides-Extra: all
+Requires-Dist: anthropic>=0.18.0; extra == 'all'
+Requires-Dist: langfuse>=2.0.0; extra == 'all'
+Requires-Dist: litellm>=1.0.0; extra == 'all'
+Requires-Dist: openai>=1.0.0; extra == 'all'
+Requires-Dist: redis>=5.0.0; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.18.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: langfuse
+Requires-Dist: langfuse>=2.0.0; extra == 'langfuse'
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.0.0; extra == 'litellm'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == 'redis'
+Description-Content-Type: text/markdown
+
+# agent-runtime-core
+
+[![PyPI version](https://badge.fury.io/py/agent-runtime-core.svg)](https://badge.fury.io/py/agent-runtime-core)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A lightweight, framework-agnostic Python library for building AI agent systems. Provides the core abstractions and implementations needed to build production-ready AI agents without tying you to any specific framework.
+
+## Features
+
+- 🔌 **Framework Agnostic** - Works with LangGraph, CrewAI, OpenAI Agents, or your own custom loops
+- 🤖 **Model Agnostic** - OpenAI, Anthropic, or any provider via LiteLLM
+- 📦 **Zero Required Dependencies** - Core library has no dependencies; add only what you need
+- 🔄 **Async First** - Built for modern async Python with full sync support
+- 🛠️ **Pluggable Backends** - Memory, Redis, or SQLite for queues, events, and state
+- 📊 **Observable** - Built-in tracing with optional Langfuse integration
+- 🧩 **Composable** - Mix and match components to build your ideal agent system
+
+## Installation
+
+```bash
+# Core library (no dependencies)
+pip install agent-runtime-core
+
+# With specific LLM providers
+pip install agent-runtime-core[openai]
+pip install agent-runtime-core[anthropic]
+pip install agent-runtime-core[litellm]
+
+# With Redis backend support
+pip install agent-runtime-core[redis]
+
+# With observability
+pip install agent-runtime-core[langfuse]
+
+# Everything
+pip install agent-runtime-core[all]
+```
+
+## Quick Start
+
+### Basic Configuration
+
+```python
+from agent_runtime import configure, get_config
+
+# Configure the runtime
+configure(
+    model_provider="openai",
+    openai_api_key="sk-...",  # Or use OPENAI_API_KEY env var
+    default_model="gpt-4o",
+)
+
+# Access configuration anywhere
+config = get_config()
+print(config.model_provider)  # "openai"
+```
+
+### Creating an Agent
+
+```python
+from agent_runtime import (
+    AgentRuntime,
+    RunContext,
+    RunResult,
+    EventType,
+    register_runtime,
+)
+
+class MyAgent(AgentRuntime):
+    """A simple conversational agent."""
+    
+    @property
+    def key(self) -> str:
+        return "my-agent"
+    
+    async def run(self, ctx: RunContext) -> RunResult:
+        # Access input messages
+        messages = ctx.input_messages
+        
+        # Get an LLM client
+        from agent_runtime.llm import get_llm_client
+        llm = get_llm_client()
+        
+        # Generate a response
+        response = await llm.generate(messages)
+        
+        # Emit events for observability
+        await ctx.emit(EventType.ASSISTANT_MESSAGE, {
+            "content": response.message["content"],
+        })
+        
+        # Return the result
+        return RunResult(
+            final_output={"response": response.message["content"]},
+            final_messages=[response.message],
+        )
+
+# Register the agent
+register_runtime(MyAgent())
+```
+
+### Using Tools
+
+```python
+from agent_runtime import Tool, ToolRegistry, RunContext, RunResult
+
+# Define tools
+def get_weather(location: str) -> str:
+    """Get the current weather for a location."""
+    return f"The weather in {location} is sunny, 72°F"
+
+def search_web(query: str) -> str:
+    """Search the web for information."""
+    return f"Search results for: {query}"
+
+# Create a tool registry
+tools = ToolRegistry()
+tools.register(Tool.from_function(get_weather))
+tools.register(Tool.from_function(search_web))
+
+class ToolAgent(AgentRuntime):
+    @property
+    def key(self) -> str:
+        return "tool-agent"
+    
+    async def run(self, ctx: RunContext) -> RunResult:
+        from agent_runtime.llm import get_llm_client
+        llm = get_llm_client()
+        
+        messages = list(ctx.input_messages)
+        
+        while True:
+            # Generate with tools
+            response = await llm.generate(
+                messages,
+                tools=tools.to_openai_format(),
+            )
+            
+            messages.append(response.message)
+            
+            # Check for tool calls
+            if not response.tool_calls:
+                break
+            
+            # Execute tools
+            for tool_call in response.tool_calls:
+                result = await tools.execute(
+                    tool_call["function"]["name"],
+                    tool_call["function"]["arguments"],
+                )
+                
+                await ctx.emit(EventType.TOOL_RESULT, {
+                    "tool_call_id": tool_call["id"],
+                    "result": result,
+                })
+                
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tool_call["id"],
+                    "content": str(result),
+                })
+        
+        return RunResult(
+            final_output={"response": response.message["content"]},
+            final_messages=messages,
+        )
+```
+
+### Running Agents
+
+```python
+from agent_runtime import AgentRunner, RunnerConfig, get_runtime
+import asyncio
+
+async def main():
+    # Get a registered agent
+    agent = get_runtime("my-agent")
+    
+    # Create a runner
+    runner = AgentRunner(
+        config=RunnerConfig(
+            run_timeout_seconds=300,
+            max_retries=3,
+        )
+    )
+    
+    # Execute a run
+    result = await runner.execute(
+        agent=agent,
+        run_id="run-123",
+        input_data={
+            "messages": [
+                {"role": "user", "content": "Hello!"}
+            ]
+        },
+    )
+    
+    print(result.final_output)
+
+asyncio.run(main())
+```
+
+## Core Concepts
+
+### AgentRuntime
+
+The base class for all agents. Implement the `run` method to define your agent's behavior:
+
+```python
+class AgentRuntime(ABC):
+    @property
+    @abstractmethod
+    def key(self) -> str:
+        """Unique identifier for this agent."""
+        pass
+    
+    @abstractmethod
+    async def run(self, ctx: RunContext) -> RunResult:
+        """Execute the agent logic."""
+        pass
+```
+
+### RunContext
+
+Provides access to the current run's state and utilities:
+
+```python
+class RunContext:
+    run_id: UUID              # Unique run identifier
+    input_messages: list      # Input messages
+    metadata: dict            # Run metadata
+    tools: ToolRegistry       # Available tools
+    
+    async def emit(self, event_type: EventType, payload: dict) -> None:
+        """Emit an event."""
+    
+    async def checkpoint(self, state: dict) -> None:
+        """Save a checkpoint."""
+    
+    def is_cancelled(self) -> bool:
+        """Check if run was cancelled."""
+```
+
+### RunResult
+
+The result of an agent run:
+
+```python
+@dataclass
+class RunResult:
+    final_output: dict           # Structured output
+    final_messages: list = None  # Conversation history
+    error: ErrorInfo = None      # Error details if failed
+```
+
+### Event Types
+
+Built-in event types for observability:
+
+- `EventType.RUN_STARTED` - Run execution began
+- `EventType.RUN_SUCCEEDED` - Run completed successfully
+- `EventType.RUN_FAILED` - Run failed with error
+- `EventType.TOOL_CALL` - Tool was invoked
+- `EventType.TOOL_RESULT` - Tool returned result
+- `EventType.ASSISTANT_MESSAGE` - LLM generated message
+- `EventType.CHECKPOINT` - State checkpoint saved
+
+## Backend Options
+
+### Queue Backends
+
+```python
+from agent_runtime.queue import MemoryQueue, RedisQueue
+
+# In-memory (for development)
+queue = MemoryQueue()
+
+# Redis (for production)
+queue = RedisQueue(redis_url="redis://localhost:6379/0")
+```
+
+### Event Bus Backends
+
+```python
+from agent_runtime.events import MemoryEventBus, RedisEventBus
+
+# In-memory
+event_bus = MemoryEventBus()
+
+# Redis Pub/Sub
+event_bus = RedisEventBus(redis_url="redis://localhost:6379/0")
+```
+
+### State Store Backends
+
+```python
+from agent_runtime.state import MemoryStateStore, RedisStateStore, SQLiteStateStore
+
+# In-memory
+state = MemoryStateStore()
+
+# Redis
+state = RedisStateStore(redis_url="redis://localhost:6379/0")
+
+# SQLite (persistent, single-node)
+state = SQLiteStateStore(db_path="./agent_state.db")
+```
+
+## LLM Clients
+
+### OpenAI
+
+```python
+from agent_runtime.llm import OpenAIClient
+
+client = OpenAIClient(
+    api_key="sk-...",  # Or use OPENAI_API_KEY env var
+    default_model="gpt-4o",
+)
+
+response = await client.generate([
+    {"role": "user", "content": "Hello!"}
+])
+```
+
+### Anthropic
+
+```python
+from agent_runtime.llm import AnthropicClient
+
+client = AnthropicClient(
+    api_key="sk-ant-...",  # Or use ANTHROPIC_API_KEY env var
+    default_model="claude-3-5-sonnet-20241022",
+)
+```
+
+### LiteLLM (Any Provider)
+
+```python
+from agent_runtime.llm import LiteLLMClient
+
+# Use any LiteLLM-supported model
+client = LiteLLMClient(default_model="gpt-4o")
+client = LiteLLMClient(default_model="claude-3-5-sonnet-20241022")
+client = LiteLLMClient(default_model="ollama/llama2")
+```
+
+## Tracing & Observability
+
+### Langfuse Integration
+
+```python
+from agent_runtime import configure
+
+configure(
+    langfuse_enabled=True,
+    langfuse_public_key="pk-...",
+    langfuse_secret_key="sk-...",
+)
+```
+
+### Custom Trace Sink
+
+```python
+from agent_runtime import TraceSink
+
+class MyTraceSink(TraceSink):
+    async def trace(self, event: dict) -> None:
+        # Send to your observability platform
+        print(f"Trace: {event}")
+```
+
+## Integration with Django
+
+For Django applications, use [django-agent-runtime](https://pypi.org/project/django-agent-runtime/) which provides:
+
+- Django models for conversations, runs, and events
+- REST API endpoints
+- Server-Sent Events (SSE) for real-time streaming
+- Management commands for running workers
+- PostgreSQL-backed queue and event bus
+
+```bash
+pip install django-agent-runtime
+```
+
+## API Reference
+
+### Configuration
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `model_provider` | str | `"openai"` | LLM provider: openai, anthropic, litellm |
+| `default_model` | str | `"gpt-4o"` | Default model to use |
+| `queue_backend` | str | `"memory"` | Queue backend: memory, redis |
+| `event_bus_backend` | str | `"memory"` | Event bus: memory, redis |
+| `state_store_backend` | str | `"memory"` | State store: memory, redis, sqlite |
+| `redis_url` | str | `None` | Redis connection URL |
+| `langfuse_enabled` | bool | `False` | Enable Langfuse tracing |
+
+### Registry Functions
+
+```python
+register_runtime(runtime: AgentRuntime) -> None
+get_runtime(key: str) -> AgentRuntime
+list_runtimes() -> list[str]
+unregister_runtime(key: str) -> None
+clear_registry() -> None
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

{agent_runtime_core-0.1.0.dist-info → agent_runtime_core-0.1.2.dist-info}/RECORD

@@ -1,8 +1,9 @@
-agent_runtime/__init__.py,sha256=wuWpDXsLUB57Psgd97MrjkRoINvO6NuxUwZQZUON3aU,2098
+agent_runtime/__init__.py,sha256=4d_QOOgxuntU8u6ltwJ__BNFzO-tAKfv0nHM8dCqf5g,2430
 agent_runtime/config.py,sha256=ZRjpILjsjeh_kl7873DtV2g_zaTrfdkb3NgdQ6ndb5Y,4981
 agent_runtime/interfaces.py,sha256=AGDY0w6muQnNiice9O3ogb8fRdgMRW6wqXpxcuyn0N0,10103
 agent_runtime/registry.py,sha256=sa0speDFxFCZlXoCge8cPNqWYUeWHyazs6tBer5Jg1w,1471
 agent_runtime/runner.py,sha256=Sb2FfSJvATaL7ideQZy2JhVZp0sSYGVIov93E-gxODU,12741
+agent_runtime/testing.py,sha256=aqN67RdbTdYf_rJfp5pEpn2s_tkeU-3oSpzTdADxH5g,11126
 agent_runtime/events/__init__.py,sha256=JNH-D40O6yz2evIf1_r2o3w7OQjLt4Yebn-sBNLzzh8,1550
 agent_runtime/events/base.py,sha256=NfHYyoczxr40Er5emROi_aY_07m5hDrKsn31pdWY2DY,1950
 agent_runtime/events/memory.py,sha256=7qseR6RtdaP833FxEHwyPw5TC7l4brJHr8uEx0mLc1Y,2486
@@ -25,7 +26,7 @@ agent_runtime/state/sqlite.py,sha256=NwuiTBXELb2tyOoH91MZqRJaCk9h8PskyY2VUc5EMr0
 agent_runtime/tracing/__init__.py,sha256=m4WzfgJpnV5XCCoMpBYZdJU_JTkAdhEhl7M7tpf62RY,1246
 agent_runtime/tracing/langfuse.py,sha256=uThF0P6f1VJ1l1b7UuiFQ-oHZ-tCa9MbbHvTqkSuQ2A,3650
 agent_runtime/tracing/noop.py,sha256=MOm5eTrnf3d4WhiWrwVU5Kd3GmJ1903V0U7U3Qwho7U,746
-agent_runtime_core-0.1.0.dist-info/METADATA,sha256=js52zDqOlTnalHxspGoPZ31vcOHZAMINC8ln5dLC72Y,2274
-agent_runtime_core-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-agent_runtime_core-0.1.0.dist-info/licenses/LICENSE,sha256=PcOO8aiOZ4H2MWYeKIis3o6xTCT1hNkDyCxHZhh1NeM,1070
-agent_runtime_core-0.1.0.dist-info/RECORD,,
+agent_runtime_core-0.1.2.dist-info/METADATA,sha256=md3hU685e-GWY_TCri5W768EKzkto0j4IpG_j70Kx7s,12478
+agent_runtime_core-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+agent_runtime_core-0.1.2.dist-info/licenses/LICENSE,sha256=PcOO8aiOZ4H2MWYeKIis3o6xTCT1hNkDyCxHZhh1NeM,1070
+agent_runtime_core-0.1.2.dist-info/RECORD,,

agent_runtime_core-0.1.0.dist-info/METADATA

@@ -1,75 +0,0 @@
-Metadata-Version: 2.4
-Name: agent-runtime-core
-Version: 0.1.0
-Summary: Framework-agnostic Python library for executing AI agents with consistent patterns
-Project-URL: Homepage, https://github.com/colstrom/agent_runtime
-Project-URL: Repository, https://github.com/colstrom/agent_runtime
-Author: Chris Olstrom
-License-Expression: MIT
-License-File: LICENSE
-Keywords: agents,ai,async,llm,runtime
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.11
-Provides-Extra: all
-Requires-Dist: anthropic>=0.18.0; extra == 'all'
-Requires-Dist: langfuse>=2.0.0; extra == 'all'
-Requires-Dist: litellm>=1.0.0; extra == 'all'
-Requires-Dist: openai>=1.0.0; extra == 'all'
-Requires-Dist: redis>=5.0.0; extra == 'all'
-Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.18.0; extra == 'anthropic'
-Provides-Extra: dev
-Requires-Dist: mypy>=1.0.0; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
-Requires-Dist: pytest>=8.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.1.0; extra == 'dev'
-Provides-Extra: langfuse
-Requires-Dist: langfuse>=2.0.0; extra == 'langfuse'
-Provides-Extra: litellm
-Requires-Dist: litellm>=1.0.0; extra == 'litellm'
-Provides-Extra: openai
-Requires-Dist: openai>=1.0.0; extra == 'openai'
-Provides-Extra: redis
-Requires-Dist: redis>=5.0.0; extra == 'redis'
-Description-Content-Type: text/markdown
-
-# agent_runtime
-
-Framework-agnostic agent runtime library for Python.
-
-## Installation
-
-```bash
-pip install agent_runtime
-```
-
-## Quick Start
-
-```python
-from agent_runtime import configure, get_llm_client
-
-# Configure
-configure(
-    model_provider="openai",
-    openai_api_key="sk-..."
-)
-
-# Get LLM client
-llm = get_llm_client()
-```
-
-## Features
-
-- Pluggable backends (memory, redis, sqlite)
-- LLM client abstractions (OpenAI, Anthropic, LiteLLM)
-- Event streaming
-- State management
-- Queue-based execution