agent-runtime-core 0.2.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

{agent_runtime → agent_runtime_core}/persistence/file.py

@@ -15,7 +15,7 @@ from pathlib import Path
 from typing import Any, Optional
 from uuid import UUID
 
-from agent_runtime.persistence.base import (
+from agent_runtime_core.persistence.base import (
     MemoryStore,
     ConversationStore,
     TaskStore,

{agent_runtime → agent_runtime_core}/persistence/manager.py

@@ -8,20 +8,32 @@ For Django integration, you can either:
 1. Pass pre-instantiated store instances
 2. Pass store classes with appropriate kwargs
 3. Use factory functions for request-scoped stores
+
+Core stores (always available):
+- MemoryStore: Key-value storage
+- ConversationStore: Conversation history
+- TaskStore: Task lists and progress
+- PreferencesStore: User/agent configuration
+
+Optional stores (must be explicitly configured):
+- KnowledgeStore: Facts, summaries, embeddings
+- AuditStore: Logs, errors, metrics
 """
 
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Callable, Optional, Type, Union
 
-from agent_runtime.persistence.base import (
+from agent_runtime_core.persistence.base import (
     MemoryStore,
     ConversationStore,
     TaskStore,
     PreferencesStore,
+    KnowledgeStore,
+    AuditStore,
     Scope,
 )
-from agent_runtime.persistence.file import (
+from agent_runtime_core.persistence.file import (
     FileMemoryStore,
     FileConversationStore,
     FileTaskStore,
@@ -34,6 +46,8 @@ MemoryStoreFactory = Callable[[], MemoryStore]
 ConversationStoreFactory = Callable[[], ConversationStore]
 TaskStoreFactory = Callable[[], TaskStore]
 PreferencesStoreFactory = Callable[[], PreferencesStore]
+KnowledgeStoreFactory = Callable[[], KnowledgeStore]
+AuditStoreFactory = Callable[[], AuditStore]
 
 
 @dataclass
@@ -46,6 +60,9 @@ class PersistenceConfig:
     - A pre-instantiated store instance
     - A factory function that returns a store instance
 
+    Core stores (memory, conversations, tasks, preferences) have file-based
+    defaults. Optional stores (knowledge, audit) must be explicitly configured.
+
     Example for Django:
         from myapp.stores import DjangoMemoryStore, DjangoConversationStore
 
@@ -65,31 +82,47 @@ class PersistenceConfig:
         config = PersistenceConfig(
             memory_store_factory=lambda: DjangoMemoryStore(user=get_current_user()),
         )
+
+        # Option 4: Enable optional stores
+        config = PersistenceConfig(
+            knowledge_store=DjangoKnowledgeStore(user=request.user),
+            audit_store=DjangoAuditStore(user=request.user),
+        )
     """
 
-    # Backend classes (can be swapped for custom implementations)
+    # Backend classes for core stores (can be swapped for custom implementations)
     memory_store_class: Type[MemoryStore] = FileMemoryStore
     conversation_store_class: Type[ConversationStore] = FileConversationStore
     task_store_class: Type[TaskStore] = FileTaskStore
     preferences_store_class: Type[PreferencesStore] = FilePreferencesStore
 
+    # Backend classes for optional stores (no defaults - must be explicitly set)
+    knowledge_store_class: Optional[Type[KnowledgeStore]] = None
+    audit_store_class: Optional[Type[AuditStore]] = None
+
     # Pre-instantiated store instances (takes precedence over classes)
     memory_store: Optional[MemoryStore] = None
     conversation_store: Optional[ConversationStore] = None
     task_store: Optional[TaskStore] = None
     preferences_store: Optional[PreferencesStore] = None
+    knowledge_store: Optional[KnowledgeStore] = None
+    audit_store: Optional[AuditStore] = None
 
     # Factory functions (takes precedence over classes, but not instances)
     memory_store_factory: Optional[MemoryStoreFactory] = None
     conversation_store_factory: Optional[ConversationStoreFactory] = None
     task_store_factory: Optional[TaskStoreFactory] = None
     preferences_store_factory: Optional[PreferencesStoreFactory] = None
+    knowledge_store_factory: Optional[KnowledgeStoreFactory] = None
+    audit_store_factory: Optional[AuditStoreFactory] = None
 
     # Kwargs passed to store class constructors (only used with classes)
     memory_store_kwargs: dict = field(default_factory=dict)
     conversation_store_kwargs: dict = field(default_factory=dict)
     task_store_kwargs: dict = field(default_factory=dict)
     preferences_store_kwargs: dict = field(default_factory=dict)
+    knowledge_store_kwargs: dict = field(default_factory=dict)
+    audit_store_kwargs: dict = field(default_factory=dict)
 
     # Project directory (convenience for file-based stores)
     # Only used if store_kwargs doesn't already have project_dir
@@ -100,8 +133,11 @@ class PersistenceManager:
     """
     Unified manager for all persistence stores.
 
-    Provides access to memory, conversations, tasks, and preferences
-    with pluggable backends.
+    Provides access to core stores (memory, conversations, tasks, preferences)
+    and optional stores (knowledge, audit) with pluggable backends.
+
+    Core stores have file-based defaults. Optional stores return None
+    unless explicitly configured.
 
     Example:
         # Use default file-based storage
@@ -120,8 +156,15 @@ class PersistenceManager:
         config = PersistenceConfig(
             memory_store=DjangoMemoryStore(user=request.user),
             conversation_store=DjangoConversationStore(user=request.user),
+            # Enable optional stores
+            knowledge_store=DjangoKnowledgeStore(user=request.user),
+            audit_store=DjangoAuditStore(user=request.user),
         )
         manager = PersistenceManager(config)
+
+        # Check if optional stores are available
+        if manager.knowledge:
+            await manager.knowledge.save_fact(fact)
     """
 
     def __init__(self, config: Optional[PersistenceConfig] = None):
@@ -130,6 +173,11 @@ class PersistenceManager:
         self._conversations: Optional[ConversationStore] = None
         self._tasks: Optional[TaskStore] = None
         self._preferences: Optional[PreferencesStore] = None
+        self._knowledge: Optional[KnowledgeStore] = None
+        self._audit: Optional[AuditStore] = None
+        # Track if optional stores have been initialized
+        self._knowledge_initialized = False
+        self._audit_initialized = False
 
     def _build_kwargs(self, store_kwargs: dict) -> dict:
         """Build kwargs for store instantiation."""
@@ -193,6 +241,54 @@ class PersistenceManager:
                 self._preferences = self._config.preferences_store_class(**kwargs)
         return self._preferences
 
+    @property
+    def knowledge(self) -> Optional[KnowledgeStore]:
+        """
+        Get the knowledge store (optional).
+
+        Returns None if not configured. Check before using:
+            if manager.knowledge:
+                await manager.knowledge.save_fact(fact)
+        """
+        if not self._knowledge_initialized:
+            self._knowledge_initialized = True
+            if self._config.knowledge_store is not None:
+                self._knowledge = self._config.knowledge_store
+            elif self._config.knowledge_store_factory is not None:
+                self._knowledge = self._config.knowledge_store_factory()
+            elif self._config.knowledge_store_class is not None:
+                kwargs = self._build_kwargs(self._config.knowledge_store_kwargs)
+                self._knowledge = self._config.knowledge_store_class(**kwargs)
+        return self._knowledge
+
+    @property
+    def audit(self) -> Optional[AuditStore]:
+        """
+        Get the audit store (optional).
+
+        Returns None if not configured. Check before using:
+            if manager.audit:
+                await manager.audit.log_event(entry)
+        """
+        if not self._audit_initialized:
+            self._audit_initialized = True
+            if self._config.audit_store is not None:
+                self._audit = self._config.audit_store
+            elif self._config.audit_store_factory is not None:
+                self._audit = self._config.audit_store_factory()
+            elif self._config.audit_store_class is not None:
+                kwargs = self._build_kwargs(self._config.audit_store_kwargs)
+                self._audit = self._config.audit_store_class(**kwargs)
+        return self._audit
+
+    def has_knowledge(self) -> bool:
+        """Check if knowledge store is configured."""
+        return self.knowledge is not None
+
+    def has_audit(self) -> bool:
+        """Check if audit store is configured."""
+        return self.audit is not None
+
     async def close(self) -> None:
         """Close all stores."""
         if self._memory:
@@ -203,6 +299,10 @@ class PersistenceManager:
             await self._tasks.close()
         if self._preferences:
             await self._preferences.close()
+        if self._knowledge:
+            await self._knowledge.close()
+        if self._audit:
+            await self._audit.close()
 
 
 # Global manager instance
@@ -215,27 +315,31 @@ def configure_persistence(
     conversation_store_class: Optional[Type[ConversationStore]] = None,
     task_store_class: Optional[Type[TaskStore]] = None,
     preferences_store_class: Optional[Type[PreferencesStore]] = None,
+    knowledge_store_class: Optional[Type[KnowledgeStore]] = None,
+    audit_store_class: Optional[Type[AuditStore]] = None,
     project_dir: Optional[Path] = None,
     **kwargs,
 ) -> PersistenceConfig:
     """
     Configure the global persistence manager.
-    
+
     Args:
         memory_store_class: Custom memory store implementation
         conversation_store_class: Custom conversation store implementation
         task_store_class: Custom task store implementation
         preferences_store_class: Custom preferences store implementation
+        knowledge_store_class: Custom knowledge store implementation (optional)
+        audit_store_class: Custom audit store implementation (optional)
         project_dir: Project directory for PROJECT scope
         **kwargs: Additional store-specific configuration
-    
+
     Returns:
         The configured PersistenceConfig
     """
     global _config, _manager
-    
+
     config = PersistenceConfig(project_dir=project_dir)
-    
+
     if memory_store_class:
         config.memory_store_class = memory_store_class
     if conversation_store_class:
@@ -244,23 +348,27 @@ def configure_persistence(
         config.task_store_class = task_store_class
     if preferences_store_class:
         config.preferences_store_class = preferences_store_class
-    
+    if knowledge_store_class:
+        config.knowledge_store_class = knowledge_store_class
+    if audit_store_class:
+        config.audit_store_class = audit_store_class
+
     _config = config
     _manager = None  # Reset manager to use new config
-    
+
     return config
 
 
 def get_persistence_manager() -> PersistenceManager:
     """
     Get the global persistence manager.
-    
+
     Creates a new manager with default config if not configured.
     """
     global _manager
-    
+
     if _manager is None:
         _manager = PersistenceManager(_config)
-    
+
     return _manager
 

{agent_runtime → agent_runtime_core}/queue/__init__.py

@@ -9,8 +9,8 @@ Provides:
 - SQLiteQueue: For persistent local storage
 """
 
-from agent_runtime.queue.base import RunQueue, QueuedRun
-from agent_runtime.queue.memory import InMemoryQueue
+from agent_runtime_core.queue.base import RunQueue, QueuedRun
+from agent_runtime_core.queue.memory import InMemoryQueue
 
 __all__ = [
     "RunQueue",
@@ -31,7 +31,7 @@ def get_queue(backend: str = None, **kwargs) -> RunQueue:
     Returns:
         RunQueue instance
     """
-    from agent_runtime.config import get_config
+    from agent_runtime_core.config import get_config
     
     config = get_config()
     backend = backend or config.queue_backend
@@ -40,14 +40,14 @@ def get_queue(backend: str = None, **kwargs) -> RunQueue:
         return InMemoryQueue()
     
     elif backend == "redis":
-        from agent_runtime.queue.redis import RedisQueue
+        from agent_runtime_core.queue.redis import RedisQueue
         url = kwargs.get("url") or config.redis_url
         if not url:
             raise ValueError("redis_url is required for redis queue backend")
         return RedisQueue(url=url)
     
     elif backend == "sqlite":
-        from agent_runtime.queue.sqlite import SQLiteQueue
+        from agent_runtime_core.queue.sqlite import SQLiteQueue
         path = kwargs.get("path") or config.sqlite_path or "agent_runtime.db"
         return SQLiteQueue(path=path)
     

{agent_runtime → agent_runtime_core}/queue/memory.py

@@ -14,7 +14,7 @@ from datetime import datetime, timezone, timedelta
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.queue.base import RunQueue, QueuedRun
+from agent_runtime_core.queue.base import RunQueue, QueuedRun
 
 
 @dataclass

{agent_runtime → agent_runtime_core}/queue/redis.py

@@ -12,7 +12,7 @@ from datetime import datetime, timedelta, timezone
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.queue.base import RunQueue, QueuedRun, RunStatus
+from agent_runtime_core.queue.base import RunQueue, QueuedRun, RunStatus
 
 
 class RedisQueue(RunQueue):

{agent_runtime → agent_runtime_core}/queue/sqlite.py

@@ -14,7 +14,7 @@ from datetime import datetime, timedelta, timezone
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.queue.base import RunQueue, QueuedRun, RunStatus
+from agent_runtime_core.queue.base import RunQueue, QueuedRun, RunStatus
 
 
 class SQLiteQueue(RunQueue):

{agent_runtime → agent_runtime_core}/registry.py

@@ -7,7 +7,7 @@ looked up by key.
 
 from typing import Optional
 
-from agent_runtime.interfaces import AgentRuntime
+from agent_runtime_core.interfaces import AgentRuntime
 
 
 # Global registry

{agent_runtime → agent_runtime_core}/runner.py

@@ -17,9 +17,9 @@ from datetime import datetime, timezone
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.config import get_config
-from agent_runtime.events.base import EventBus
-from agent_runtime.interfaces import (
+from agent_runtime_core.config import get_config
+from agent_runtime_core.events.base import EventBus
+from agent_runtime_core.interfaces import (
     AgentRuntime,
     EventType,
     ErrorInfo,
@@ -27,9 +27,9 @@ from agent_runtime.interfaces import (
     RunResult,
     ToolRegistry,
 )
-from agent_runtime.queue.base import RunQueue, QueuedRun
-from agent_runtime.registry import get_runtime
-from agent_runtime.state.base import StateStore
+from agent_runtime_core.queue.base import RunQueue, QueuedRun
+from agent_runtime_core.registry import get_runtime
+from agent_runtime_core.state.base import StateStore
 
 
 @dataclass

{agent_runtime → agent_runtime_core}/state/__init__.py

@@ -8,8 +8,8 @@ Provides:
 - SQLiteStateStore: For persistent local storage
 """
 
-from agent_runtime.state.base import StateStore
-from agent_runtime.state.memory import InMemoryStateStore
+from agent_runtime_core.state.base import StateStore
+from agent_runtime_core.state.memory import InMemoryStateStore
 
 __all__ = [
     "StateStore",
@@ -29,7 +29,7 @@ def get_state_store(backend: str = None, **kwargs) -> StateStore:
     Returns:
         StateStore instance
     """
-    from agent_runtime.config import get_config
+    from agent_runtime_core.config import get_config
     
     config = get_config()
     backend = backend or config.state_store_backend
@@ -38,14 +38,14 @@ def get_state_store(backend: str = None, **kwargs) -> StateStore:
         return InMemoryStateStore()
     
     elif backend == "redis":
-        from agent_runtime.state.redis import RedisStateStore
+        from agent_runtime_core.state.redis import RedisStateStore
         url = kwargs.get("url") or config.redis_url
         if not url:
             raise ValueError("redis_url is required for redis state store backend")
         return RedisStateStore(url=url)
     
     elif backend == "sqlite":
-        from agent_runtime.state.sqlite import SQLiteStateStore
+        from agent_runtime_core.state.sqlite import SQLiteStateStore
         path = kwargs.get("path") or config.sqlite_path or "agent_runtime.db"
         return SQLiteStateStore(path=path)
     

{agent_runtime → agent_runtime_core}/state/memory.py

@@ -10,7 +10,7 @@ Good for:
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.state.base import StateStore
+from agent_runtime_core.state.base import StateStore
 
 
 class InMemoryStateStore(StateStore):

{agent_runtime → agent_runtime_core}/state/redis.py

@@ -12,7 +12,7 @@ from datetime import datetime
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.state.base import StateStore, Checkpoint
+from agent_runtime_core.state.base import StateStore, Checkpoint
 
 
 class RedisStateStore(StateStore):

{agent_runtime → agent_runtime_core}/state/sqlite.py

@@ -15,7 +15,7 @@ from pathlib import Path
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.state.base import StateStore, Checkpoint
+from agent_runtime_core.state.base import StateStore, Checkpoint
 
 
 class SQLiteStateStore(StateStore):

{agent_runtime → agent_runtime_core}/testing.py

@@ -8,7 +8,7 @@ This module provides tools for testing agent implementations:
 - LLMEvaluator: Use LLM to evaluate agent responses
 
 Example usage:
-    from agent_runtime.testing import MockRunContext, MockLLMClient, AgentTestCase
+    from agent_runtime_core.testing import MockRunContext, MockLLMClient, AgentTestCase
     
     class TestMyAgent(AgentTestCase):
         async def test_agent_responds(self):

{agent_runtime → agent_runtime_core}/tracing/__init__.py

@@ -7,7 +7,7 @@ Provides:
 - LangfuseTraceSink: Langfuse integration
 """
 
-from agent_runtime.tracing.noop import NoopTraceSink
+from agent_runtime_core.tracing.noop import NoopTraceSink
 
 __all__ = [
     "NoopTraceSink",
@@ -26,8 +26,8 @@ def get_trace_sink(backend: str = None, **kwargs):
     Returns:
         TraceSink instance
     """
-    from agent_runtime.config import get_config
-    from agent_runtime.interfaces import TraceSink
+    from agent_runtime_core.config import get_config
+    from agent_runtime_core.interfaces import TraceSink
     
     config = get_config()
     backend = backend or config.tracing_backend or "noop"
@@ -36,7 +36,7 @@ def get_trace_sink(backend: str = None, **kwargs):
         return NoopTraceSink()
     
     elif backend == "langfuse":
-        from agent_runtime.tracing.langfuse import LangfuseTraceSink
+        from agent_runtime_core.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,

{agent_runtime → agent_runtime_core}/tracing/langfuse.py

@@ -11,7 +11,7 @@ import logging
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.interfaces import TraceSink
+from agent_runtime_core.interfaces import TraceSink
 
 try:
     from langfuse import Langfuse

{agent_runtime → agent_runtime_core}/tracing/noop.py

@@ -7,7 +7,7 @@ Used when tracing is disabled or not configured.
 from typing import Optional
 from uuid import UUID
 
-from agent_runtime.interfaces import TraceSink
+from agent_runtime_core.interfaces import TraceSink
 
 
 class NoopTraceSink(TraceSink):