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

agent_runtime/state/sqlite.py

@@ -0,0 +1,158 @@
+"""
+SQLite state store implementation.
+
+Good for:
+- Local development with persistence
+- Single-process deployments
+- Testing with real database
+"""
+
+import json
+import sqlite3
+from contextlib import contextmanager
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from uuid import UUID
+
+from agent_runtime.state.base import StateStore, Checkpoint
+
+
+class SQLiteStateStore(StateStore):
+    """
+    SQLite-backed state store.
+    
+    Stores checkpoints in a local SQLite database.
+    Supports both file-based and in-memory databases.
+    """
+    
+    def __init__(self, path: str = "agent_runtime.db"):
+        """
+        Initialize SQLite state store.
+        
+        Args:
+            path: Path to SQLite database file, or ":memory:" for in-memory
+        """
+        self.path = path
+        self._initialized = False
+    
+    @contextmanager
+    def _get_connection(self):
+        """Get a database connection."""
+        conn = sqlite3.connect(self.path)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+        finally:
+            conn.close()
+    
+    def _ensure_initialized(self):
+        """Ensure the database schema exists."""
+        if self._initialized:
+            return
+        
+        with self._get_connection() as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS checkpoints (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    run_id TEXT NOT NULL,
+                    seq INTEGER NOT NULL,
+                    state TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    UNIQUE(run_id, seq)
+                )
+            """)
+            conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_checkpoints_run_id 
+                ON checkpoints(run_id)
+            """)
+            conn.commit()
+        
+        self._initialized = True
+    
+    async def save_checkpoint(self, checkpoint: Checkpoint) -> None:
+        """Save a checkpoint."""
+        self._ensure_initialized()
+        
+        with self._get_connection() as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO checkpoints (run_id, seq, state, created_at)
+                VALUES (?, ?, ?, ?)
+                """,
+                (
+                    str(checkpoint.run_id),
+                    checkpoint.seq,
+                    json.dumps(checkpoint.state),
+                    checkpoint.created_at.isoformat(),
+                ),
+            )
+            conn.commit()
+    
+    async def get_latest_checkpoint(self, run_id: UUID) -> Optional[Checkpoint]:
+        """Get the latest checkpoint for a run."""
+        self._ensure_initialized()
+        
+        with self._get_connection() as conn:
+            row = conn.execute(
+                """
+                SELECT run_id, seq, state, created_at
+                FROM checkpoints
+                WHERE run_id = ?
+                ORDER BY seq DESC
+                LIMIT 1
+                """,
+                (str(run_id),),
+            ).fetchone()
+            
+            if not row:
+                return None
+            
+            return Checkpoint(
+                run_id=UUID(row["run_id"]),
+                seq=row["seq"],
+                state=json.loads(row["state"]),
+                created_at=datetime.fromisoformat(row["created_at"]),
+            )
+    
+    async def get_checkpoints(self, run_id: UUID) -> list[Checkpoint]:
+        """Get all checkpoints for a run."""
+        self._ensure_initialized()
+        
+        with self._get_connection() as conn:
+            rows = conn.execute(
+                """
+                SELECT run_id, seq, state, created_at
+                FROM checkpoints
+                WHERE run_id = ?
+                ORDER BY seq ASC
+                """,
+                (str(run_id),),
+            ).fetchall()
+            
+            return [
+                Checkpoint(
+                    run_id=UUID(row["run_id"]),
+                    seq=row["seq"],
+                    state=json.loads(row["state"]),
+                    created_at=datetime.fromisoformat(row["created_at"]),
+                )
+                for row in rows
+            ]
+    
+    async def get_next_seq(self, run_id: UUID) -> int:
+        """Get the next sequence number for a run."""
+        latest = await self.get_latest_checkpoint(run_id)
+        return (latest.seq + 1) if latest else 0
+    
+    async def delete_checkpoints(self, run_id: UUID) -> int:
+        """Delete all checkpoints for a run."""
+        self._ensure_initialized()
+        
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                "DELETE FROM checkpoints WHERE run_id = ?",
+                (str(run_id),),
+            )
+            conn.commit()
+            return cursor.rowcount

agent_runtime/tracing/__init__.py

@@ -0,0 +1,47 @@
+"""
+Tracing implementations for observability.
+
+Provides:
+- TraceSink: Abstract interface
+- NoopTraceSink: No-op implementation
+- LangfuseTraceSink: Langfuse integration
+"""
+
+from agent_runtime.tracing.noop import NoopTraceSink
+
+__all__ = [
+    "NoopTraceSink",
+    "get_trace_sink",
+]
+
+
+def get_trace_sink(backend: str = None, **kwargs):
+    """
+    Factory function to get a trace sink.
+    
+    Args:
+        backend: "noop" or "langfuse"
+        **kwargs: Backend-specific configuration
+        
+    Returns:
+        TraceSink instance
+    """
+    from agent_runtime.config import get_config
+    from agent_runtime.interfaces import TraceSink
+    
+    config = get_config()
+    backend = backend or config.tracing_backend or "noop"
+    
+    if backend == "noop":
+        return NoopTraceSink()
+    
+    elif backend == "langfuse":
+        from agent_runtime.tracing.langfuse import LangfuseTraceSink
+        return LangfuseTraceSink(
+            public_key=kwargs.get("public_key") or config.langfuse_public_key,
+            secret_key=kwargs.get("secret_key") or config.langfuse_secret_key,
+            host=kwargs.get("host") or config.langfuse_host,
+        )
+    
+    else:
+        raise ValueError(f"Unknown tracing backend: {backend}")

agent_runtime/tracing/langfuse.py

@@ -0,0 +1,119 @@
+"""
+Langfuse trace sink implementation.
+
+Langfuse is an open-source LLM observability platform.
+This is an OPTIONAL integration - the core runtime doesn't depend on it.
+
+See: https://langfuse.com/
+"""
+
+import logging
+from typing import Optional
+from uuid import UUID
+
+from agent_runtime.interfaces import TraceSink
+
+try:
+    from langfuse import Langfuse
+except ImportError:
+    Langfuse = None
+
+logger = logging.getLogger(__name__)
+
+
+class LangfuseTraceSink(TraceSink):
+    """
+    Langfuse trace sink for LLM observability.
+
+    Sends traces to Langfuse for monitoring, debugging, and analytics.
+    """
+
+    def __init__(
+        self,
+        public_key: Optional[str] = None,
+        secret_key: Optional[str] = None,
+        host: Optional[str] = None,
+    ):
+        if Langfuse is None:
+            raise ImportError(
+                "langfuse package is required for LangfuseTraceSink. "
+                "Install with: pip install agent_runtime[langfuse]"
+            )
+
+        self._client = Langfuse(
+            public_key=public_key,
+            secret_key=secret_key,
+            host=host,
+        )
+        self._traces: dict[UUID, any] = {}
+
+    def start_run(self, run_id: UUID, metadata: dict) -> None:
+        """Start a new trace in Langfuse."""
+        try:
+            trace = self._client.trace(
+                id=str(run_id),
+                name=metadata.get("agent_key", "agent_run"),
+                metadata=metadata,
+            )
+            self._traces[run_id] = trace
+        except Exception as e:
+            logger.warning(f"Failed to start Langfuse trace: {e}")
+
+    def log_event(self, run_id: UUID, event_type: str, payload: dict) -> None:
+        """Log an event to the trace."""
+        trace = self._traces.get(run_id)
+        if not trace:
+            return
+
+        try:
+            # Map event types to Langfuse concepts
+            if event_type == "assistant.message":
+                trace.generation(
+                    name="assistant_message",
+                    output=payload.get("content", ""),
+                    metadata=payload,
+                )
+            elif event_type == "tool.call":
+                trace.span(
+                    name=f"tool:{payload.get('name', 'unknown')}",
+                    input=payload.get("arguments", {}),
+                )
+            elif event_type == "tool.result":
+                # Tool results are logged as part of the span
+                pass
+            else:
+                # Generic event
+                trace.event(
+                    name=event_type,
+                    metadata=payload,
+                )
+        except Exception as e:
+            logger.warning(f"Failed to log Langfuse event: {e}")
+
+    def end_run(self, run_id: UUID, outcome: str, metadata: Optional[dict] = None) -> None:
+        """End the trace."""
+        trace = self._traces.pop(run_id, None)
+        if not trace:
+            return
+
+        try:
+            # Update trace with final status
+            status_map = {
+                "succeeded": "SUCCESS",
+                "failed": "ERROR",
+                "cancelled": "CANCELLED",
+                "timed_out": "ERROR",
+            }
+            trace.update(
+                status=status_map.get(outcome, "UNKNOWN"),
+                metadata=metadata or {},
+            )
+        except Exception as e:
+            logger.warning(f"Failed to end Langfuse trace: {e}")
+
+    def flush(self) -> None:
+        """Flush any buffered traces to Langfuse."""
+        try:
+            self._client.flush()
+        except Exception as e:
+            logger.warning(f"Failed to flush Langfuse traces: {e}")

agent_runtime/tracing/noop.py

@@ -0,0 +1,34 @@
+"""
+No-op trace sink implementation.
+
+Used when tracing is disabled or not configured.
+"""
+
+from typing import Optional
+from uuid import UUID
+
+from agent_runtime.interfaces import TraceSink
+
+
+class NoopTraceSink(TraceSink):
+    """
+    No-op trace sink that discards all traces.
+    
+    Used when tracing is disabled.
+    """
+    
+    def start_run(self, run_id: UUID, metadata: dict) -> None:
+        """No-op."""
+        pass
+    
+    def log_event(self, run_id: UUID, event_type: str, payload: dict) -> None:
+        """No-op."""
+        pass
+    
+    def end_run(self, run_id: UUID, outcome: str, metadata: Optional[dict] = None) -> None:
+        """No-op."""
+        pass
+    
+    def flush(self) -> None:
+        """No-op."""
+        pass

agent_runtime_core-0.1.0.dist-info/METADATA

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

agent_runtime_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+agent_runtime/__init__.py,sha256=wuWpDXsLUB57Psgd97MrjkRoINvO6NuxUwZQZUON3aU,2098
+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/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
+agent_runtime/events/redis.py,sha256=Z6WEvp_6jcIPi4ZgkGk5J61qxgGqllwk7jqJM4jcTXk,5869
+agent_runtime/events/sqlite.py,sha256=EiX1BMOqeS7BelmD8A6cvhz3fE4w7vJ2Wg4pFu1V2u0,5092
+agent_runtime/llm/__init__.py,sha256=JEk1Q2H6U9_Uid48YVm1wYR1W7po0vtjfjf2TTmQe_A,2431
+agent_runtime/llm/anthropic.py,sha256=R5KIcHAvHwoibkI0bXxg0RXlwd1qRGcdlGEEEoApVCM,7491
+agent_runtime/llm/litellm_client.py,sha256=M_-dAJVMRfWeNJlB0HXpFykbiIDRGwq1uMnamO3XUr8,5178
+agent_runtime/llm/openai.py,sha256=eL6_lhsUvwlE24TfDnzmlF285M0tExjb00rJV43oz28,6837
+agent_runtime/queue/__init__.py,sha256=78k29iEl8brp71LrOnmTHhQzPMHkzGre-Xqdl1NlNr0,1502
+agent_runtime/queue/base.py,sha256=QW1eWbwBX_tmVD8yJobFJtlxLd_RtUWHTuXGessuxy8,3959
+agent_runtime/queue/memory.py,sha256=n7kiE0Fw_BFUdzMyoO1QPO0ATzz8zBYaMQex7GdceZw,5411
+agent_runtime/queue/redis.py,sha256=buTCgqNz77q7ae_eNIRRUEyhx_jCgJ0Q3Bqe1Hz5G-s,15617
+agent_runtime/queue/sqlite.py,sha256=DyV2h3C5WuI9d_FjOmleeYvL7BbttMHN1E9XcK-X15w,14333
+agent_runtime/state/__init__.py,sha256=W9juyZD8N0zj5ERkWroW7O0SLWnoYFcLjGuR4tfFKs4,1539
+agent_runtime/state/base.py,sha256=NqE3B0ySa-U2jkelgmkBbkmkaIQxfu4pDryoxkZTMrc,1593
+agent_runtime/state/memory.py,sha256=xOnlqM3ArXDKAdPx3PxdS9IGgJDSM-EKp_S1Hsit180,1561
+agent_runtime/state/redis.py,sha256=-lPi_2xKm7Bc4DVMJfSEAF7wJHctLV3ZMM9AYBeQKZU,3425
+agent_runtime/state/sqlite.py,sha256=NwuiTBXELb2tyOoH91MZqRJaCk9h8PskyY2VUc5EMr0,4868
+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.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_runtime_core-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Olstrom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.