aury-agent 0.0.4__py3-none-any.whl

aury/agents/backends/code/__init__.py

@@ -0,0 +1,65 @@
+"""Code backend for code execution.
+
+Supports executing code in various languages.
+No default implementation - user must provide one.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal, Protocol, runtime_checkable
+
+
+@dataclass
+class CodeResult:
+    """Result of code execution."""
+    output: str
+    error: str = ""
+    exit_code: int = 0
+    language: str = "python"
+    duration_ms: int = 0
+    
+    # Optional: execution artifacts (images, files, etc.)
+    artifacts: list[dict[str, Any]] = field(default_factory=list)
+    
+    @property
+    def success(self) -> bool:
+        return self.exit_code == 0
+
+
+@runtime_checkable
+class CodeBackend(Protocol):
+    """Protocol for code execution.
+    
+    No default implementation provided.
+    Users can implement using:
+    - Local subprocess execution
+    - E2B code interpreter
+    - Jupyter kernel
+    - etc.
+    """
+    
+    @property
+    def supported_languages(self) -> list[str]:
+        """List of supported languages."""
+        ...
+    
+    async def execute(
+        self,
+        code: str,
+        language: str = "python",
+        timeout: int = 120,
+    ) -> CodeResult:
+        """Execute code.
+        
+        Args:
+            code: Code to execute
+            language: Programming language
+            timeout: Timeout in seconds
+            
+        Returns:
+            CodeResult with output, error, exit_code
+        """
+        ...
+
+
+__all__ = ["CodeBackend", "CodeResult"]

aury/agents/backends/file/__init__.py

@@ -0,0 +1,11 @@
+"""File backend for file system operations.
+
+Supports different file systems:
+- Local file system
+- Sandbox file system
+- S3/Cloud storage
+"""
+from .types import FileBackend
+from .local import LocalFileBackend
+
+__all__ = ["FileBackend", "LocalFileBackend"]

aury/agents/backends/file/local.py

@@ -0,0 +1,66 @@
+"""Local file system backend."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import aiofiles
+
+
+class LocalFileBackend:
+    """Local file system backend."""
+    
+    def __init__(self, base_path: str | None = None):
+        """Initialize with optional base path for relative paths."""
+        self.base_path = Path(base_path) if base_path else None
+    
+    def _resolve(self, path: str) -> Path:
+        """Resolve path (handle relative paths if base_path set)."""
+        p = Path(path)
+        if not p.is_absolute() and self.base_path:
+            return self.base_path / p
+        return p
+    
+    async def read(self, path: str) -> str:
+        """Read file content."""
+        async with aiofiles.open(self._resolve(path), "r", encoding="utf-8") as f:
+            return await f.read()
+    
+    async def write(self, path: str, content: str) -> None:
+        """Write content to file."""
+        p = self._resolve(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        async with aiofiles.open(p, "w", encoding="utf-8") as f:
+            await f.write(content)
+    
+    async def append(self, path: str, content: str) -> None:
+        """Append content to file."""
+        p = self._resolve(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        async with aiofiles.open(p, "a", encoding="utf-8") as f:
+            await f.write(content)
+    
+    async def delete(self, path: str) -> bool:
+        """Delete file."""
+        p = self._resolve(path)
+        if p.exists():
+            p.unlink()
+            return True
+        return False
+    
+    async def exists(self, path: str) -> bool:
+        """Check if file exists."""
+        return self._resolve(path).exists()
+    
+    async def list(self, path: str, pattern: str = "*") -> list[str]:
+        """List files matching pattern."""
+        p = self._resolve(path)
+        if not p.exists():
+            return []
+        return [str(f) for f in p.glob(pattern) if f.is_file()]
+    
+    async def mkdir(self, path: str, parents: bool = True) -> None:
+        """Create directory."""
+        self._resolve(path).mkdir(parents=parents, exist_ok=True)
+
+
+__all__ = ["LocalFileBackend"]

aury/agents/backends/file/types.py

@@ -0,0 +1,40 @@
+"""File backend types and protocols."""
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class FileBackend(Protocol):
+    """Protocol for file system operations."""
+    
+    async def read(self, path: str) -> str:
+        """Read file content."""
+        ...
+    
+    async def write(self, path: str, content: str) -> None:
+        """Write content to file."""
+        ...
+    
+    async def append(self, path: str, content: str) -> None:
+        """Append content to file."""
+        ...
+    
+    async def delete(self, path: str) -> bool:
+        """Delete file. Returns True if deleted."""
+        ...
+    
+    async def exists(self, path: str) -> bool:
+        """Check if file exists."""
+        ...
+    
+    async def list(self, path: str, pattern: str = "*") -> list[str]:
+        """List files in directory matching pattern."""
+        ...
+    
+    async def mkdir(self, path: str, parents: bool = True) -> None:
+        """Create directory."""
+        ...
+
+
+__all__ = ["FileBackend"]

aury/agents/backends/invocation/__init__.py

@@ -0,0 +1,8 @@
+"""Invocation backend."""
+from .types import InvocationBackend
+from .memory import InMemoryInvocationBackend
+
+__all__ = [
+    "InvocationBackend",
+    "InMemoryInvocationBackend",
+]

aury/agents/backends/invocation/memory.py

@@ -0,0 +1,81 @@
+"""In-memory invocation backend implementation."""
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+
+class InMemoryInvocationBackend:
+    """In-memory implementation of InvocationBackend.
+    
+    Suitable for testing and simple single-process use cases.
+    """
+    
+    def __init__(self) -> None:
+        self._invocations: dict[str, dict[str, Any]] = {}
+        self._session_invocations: dict[str, list[str]] = {}
+    
+    async def create(
+        self,
+        id: str,
+        session_id: str,
+        data: dict[str, Any],
+        agent_id: str | None = None,
+    ) -> None:
+        """Create a new invocation."""
+        invocation_data = {
+            "id": id,
+            "session_id": session_id,
+            "agent_id": agent_id,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            **data,
+        }
+        self._invocations[id] = invocation_data
+        
+        if session_id not in self._session_invocations:
+            self._session_invocations[session_id] = []
+        self._session_invocations[session_id].append(id)
+    
+    async def get(self, id: str) -> dict[str, Any] | None:
+        """Get invocation by ID."""
+        return self._invocations.get(id)
+    
+    async def update(self, id: str, data: dict[str, Any]) -> None:
+        """Update invocation data."""
+        if id in self._invocations:
+            self._invocations[id].update(data)
+            self._invocations[id]["updated_at"] = datetime.now().isoformat()
+    
+    async def delete(self, id: str) -> bool:
+        """Delete an invocation."""
+        if id not in self._invocations:
+            return False
+        
+        inv = self._invocations.pop(id)
+        session_id = inv.get("session_id")
+        if session_id and session_id in self._session_invocations:
+            self._session_invocations[session_id] = [
+                iid for iid in self._session_invocations[session_id] if iid != id
+            ]
+        return True
+    
+    async def list_by_session(
+        self,
+        session_id: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """List invocations for a session."""
+        inv_ids = self._session_invocations.get(session_id, [])
+        invocations = [self._invocations[iid] for iid in inv_ids if iid in self._invocations]
+        invocations.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+        return invocations[offset:offset + limit]
+    
+    async def get_latest(self, session_id: str) -> dict[str, Any] | None:
+        """Get the latest invocation for a session."""
+        invocations = await self.list_by_session(session_id, limit=1)
+        return invocations[0] if invocations else None
+
+
+__all__ = ["InMemoryInvocationBackend"]

aury/agents/backends/invocation/types.py

@@ -0,0 +1,110 @@
+"""Invocation backend types and protocols."""
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class InvocationBackend(Protocol):
+    """Protocol for invocation management.
+    
+    An invocation represents a single user turn / agent execution cycle.
+    Each session can contain multiple invocations.
+    
+    Example usage:
+        # Create invocation
+        await backend.create(
+            id="inv_123",
+            session_id="sess_456",
+            data={"state": "running", "agent_id": "react_agent"},
+        )
+        
+        # Get invocation
+        inv = await backend.get("inv_123")
+        
+        # Update state
+        await backend.update("inv_123", {"state": "completed"})
+        
+        # List by session
+        invocations = await backend.list_by_session("sess_456")
+    """
+    
+    async def create(
+        self,
+        id: str,
+        session_id: str,
+        data: dict[str, Any],
+        agent_id: str | None = None,
+    ) -> None:
+        """Create a new invocation.
+        
+        Args:
+            id: Invocation ID
+            session_id: Parent session ID
+            data: Invocation data (state, metadata, etc.)
+            agent_id: Optional agent ID
+        """
+        ...
+    
+    async def get(self, id: str) -> dict[str, Any] | None:
+        """Get invocation by ID.
+        
+        Args:
+            id: Invocation ID
+            
+        Returns:
+            Invocation data dict or None if not found
+        """
+        ...
+    
+    async def update(self, id: str, data: dict[str, Any]) -> None:
+        """Update invocation data.
+        
+        Args:
+            id: Invocation ID
+            data: Fields to update (partial update)
+        """
+        ...
+    
+    async def delete(self, id: str) -> bool:
+        """Delete an invocation.
+        
+        Args:
+            id: Invocation ID
+            
+        Returns:
+            True if deleted, False if not found
+        """
+        ...
+    
+    async def list_by_session(
+        self,
+        session_id: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[dict[str, Any]]:
+        """List invocations for a session.
+        
+        Args:
+            session_id: Session ID to filter by
+            limit: Max invocations to return
+            offset: Offset for pagination
+            
+        Returns:
+            List of invocation data dicts, ordered by created_at desc
+        """
+        ...
+    
+    async def get_latest(self, session_id: str) -> dict[str, Any] | None:
+        """Get the latest invocation for a session.
+        
+        Args:
+            session_id: Session ID
+            
+        Returns:
+            Latest invocation data or None
+        """
+        ...
+
+
+__all__ = ["InvocationBackend"]

aury/agents/backends/memory/__init__.py

@@ -0,0 +1,8 @@
+"""Memory backend."""
+from .types import MemoryBackend
+from .memory import InMemoryMemoryBackend
+
+__all__ = [
+    "MemoryBackend",
+    "InMemoryMemoryBackend",
+]

aury/agents/backends/memory/memory.py

@@ -0,0 +1,179 @@
+"""In-memory memory backend implementation."""
+from __future__ import annotations
+
+import hashlib
+import uuid
+from datetime import datetime
+from typing import Any
+
+
+class InMemoryMemoryBackend:
+    """In-memory implementation of MemoryBackend.
+    
+    Uses simple keyword matching for search.
+    Suitable for testing and simple use cases.
+    For production, use vector database backends.
+    """
+    
+    def __init__(self) -> None:
+        self._entries: dict[str, dict[str, Any]] = {}
+        # Index: session_id -> list of entry_ids
+        self._session_entries: dict[str, list[str]] = {}
+        # Content hash for deduplication
+        self._content_hashes: dict[str, str] = {}
+    
+    def _make_key(self, session_id: str, namespace: str | None) -> str:
+        if namespace:
+            return f"{session_id}:{namespace}"
+        return session_id
+    
+    def _content_hash(self, content: str) -> str:
+        return hashlib.sha256(content.encode()).hexdigest()[:16]
+    
+    async def add(
+        self,
+        session_id: str,
+        content: str,
+        invocation_id: str | None = None,
+        namespace: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> str:
+        """Add a memory entry with deduplication."""
+        content_hash = self._content_hash(content)
+        key = self._make_key(session_id, namespace)
+        
+        # Check for duplicate
+        hash_key = f"{key}:{content_hash}"
+        if hash_key in self._content_hashes:
+            return self._content_hashes[hash_key]
+        
+        entry_id = f"mem_{uuid.uuid4().hex[:12]}"
+        entry = {
+            "id": entry_id,
+            "session_id": session_id,
+            "content": content,
+            "invocation_id": invocation_id,
+            "namespace": namespace,
+            "metadata": metadata or {},
+            "created_at": datetime.now().isoformat(),
+        }
+        
+        self._entries[entry_id] = entry
+        self._content_hashes[hash_key] = entry_id
+        
+        if key not in self._session_entries:
+            self._session_entries[key] = []
+        self._session_entries[key].append(entry_id)
+        
+        return entry_id
+    
+    async def search(
+        self,
+        session_id: str,
+        query: str,
+        namespace: str | None = None,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Simple keyword search."""
+        key = self._make_key(session_id, namespace)
+        entry_ids = self._session_entries.get(key, [])
+        
+        results = []
+        query_lower = query.lower()
+        query_words = set(query_lower.split())
+        
+        for entry_id in entry_ids:
+            entry = self._entries.get(entry_id)
+            if not entry:
+                continue
+            
+            content_lower = entry["content"].lower()
+            content_words = set(content_lower.split())
+            
+            # Calculate simple relevance score
+            overlap = len(query_words & content_words)
+            if overlap > 0:
+                score = overlap / len(query_words)
+            elif query_lower in content_lower:
+                score = 0.5
+            else:
+                continue
+            
+            results.append({
+                "id": entry["id"],
+                "content": entry["content"],
+                "score": score,
+                "metadata": entry["metadata"],
+                "invocation_id": entry.get("invocation_id"),
+            })
+        
+        results.sort(key=lambda x: x["score"], reverse=True)
+        return results[:limit]
+    
+    async def get(self, id: str) -> dict[str, Any] | None:
+        """Get memory by ID."""
+        return self._entries.get(id)
+    
+    async def delete(self, id: str) -> bool:
+        """Delete a memory entry."""
+        if id not in self._entries:
+            return False
+        
+        entry = self._entries.pop(id)
+        session_id = entry["session_id"]
+        namespace = entry.get("namespace")
+        key = self._make_key(session_id, namespace)
+        
+        if key in self._session_entries:
+            self._session_entries[key] = [
+                eid for eid in self._session_entries[key] if eid != id
+            ]
+        
+        # Remove from content hash
+        content_hash = self._content_hash(entry["content"])
+        hash_key = f"{key}:{content_hash}"
+        self._content_hashes.pop(hash_key, None)
+        
+        return True
+    
+    async def delete_by_invocation(
+        self,
+        session_id: str,
+        invocation_id: str,
+        namespace: str | None = None,
+    ) -> int:
+        """Delete memories by invocation."""
+        key = self._make_key(session_id, namespace)
+        entry_ids = self._session_entries.get(key, [])
+        
+        to_delete = [
+            eid for eid in entry_ids
+            if self._entries.get(eid, {}).get("invocation_id") == invocation_id
+        ]
+        
+        for eid in to_delete:
+            await self.delete(eid)
+        
+        return len(to_delete)
+    
+    async def list(
+        self,
+        session_id: str,
+        namespace: str | None = None,
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        """List memories for a session."""
+        key = self._make_key(session_id, namespace)
+        entry_ids = self._session_entries.get(key, [])
+        
+        entries = [
+            self._entries[eid]
+            for eid in entry_ids
+            if eid in self._entries
+        ]
+        
+        entries.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+        return entries[:limit]
+
+
+__all__ = ["InMemoryMemoryBackend"]