agent-runtime-core 0.7.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

agent_runtime_core/contexts.py

@@ -24,11 +24,15 @@ import json
 import os
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, TYPE_CHECKING
 from uuid import UUID, uuid4
 
 from agent_runtime_core.interfaces import EventType, Message, ToolRegistry
 
+if TYPE_CHECKING:
+    from agent_runtime_core.multi_agent import SystemContext
+    from agent_runtime_core.privacy import PrivacyConfig, UserContext
+
 
 class InMemoryRunContext:
     """
@@ -65,10 +69,13 @@ class InMemoryRunContext:
         metadata: Optional[dict] = None,
         tool_registry: Optional[ToolRegistry] = None,
         on_event: Optional[Callable[[str, dict], None]] = None,
+        system_context: Optional["SystemContext"] = None,
+        user_context: Optional["UserContext"] = None,
+        privacy_config: Optional["PrivacyConfig"] = None,
     ):
         """
         Initialize an in-memory run context.
-        
+
         Args:
             run_id: Unique identifier for this run (auto-generated if not provided)
             conversation_id: Associated conversation ID (optional)
@@ -77,6 +84,9 @@ class InMemoryRunContext:
             metadata: Run metadata
             tool_registry: Registry of available tools
             on_event: Optional callback for events (for testing/debugging)
+            system_context: Optional SystemContext for multi-agent systems with shared knowledge
+            user_context: Optional UserContext for user isolation and privacy
+            privacy_config: Optional PrivacyConfig for privacy settings (defaults to max privacy)
         """
         self._run_id = run_id or uuid4()
         self._conversation_id = conversation_id
@@ -88,7 +98,18 @@ class InMemoryRunContext:
         self._state: Optional[dict] = None
         self._events: list[dict] = []
         self._on_event = on_event
-    
+        self._system_context = system_context
+
+        # Import here to avoid circular imports
+        from agent_runtime_core.privacy import (
+            DEFAULT_PRIVACY_CONFIG,
+            ANONYMOUS_USER,
+        )
+
+        # Default to secure settings: anonymous user + strict privacy
+        self._user_context = user_context if user_context is not None else ANONYMOUS_USER
+        self._privacy_config = privacy_config if privacy_config is not None else DEFAULT_PRIVACY_CONFIG
+
     @property
     def run_id(self) -> UUID:
         """Unique identifier for this run."""
@@ -118,7 +139,22 @@ class InMemoryRunContext:
     def tool_registry(self) -> ToolRegistry:
         """Registry of available tools for this agent."""
         return self._tool_registry
-    
+
+    @property
+    def system_context(self) -> Optional["SystemContext"]:
+        """System context for multi-agent systems with shared knowledge."""
+        return self._system_context
+
+    @property
+    def user_context(self) -> "UserContext":
+        """User context for privacy and data isolation. Defaults to ANONYMOUS_USER."""
+        return self._user_context
+
+    @property
+    def privacy_config(self) -> "PrivacyConfig":
+        """Privacy configuration for this run. Defaults to DEFAULT_PRIVACY_CONFIG (strict)."""
+        return self._privacy_config
+
     async def emit(self, event_type: EventType | str, payload: dict) -> None:
         """Emit an event (stored in memory)."""
         event_type_str = event_type.value if hasattr(event_type, 'value') else str(event_type)
@@ -195,6 +231,9 @@ class FileRunContext:
         metadata: Optional[dict] = None,
         tool_registry: Optional[ToolRegistry] = None,
         on_event: Optional[Callable[[str, dict], None]] = None,
+        system_context: Optional["SystemContext"] = None,
+        user_context: Optional["UserContext"] = None,
+        privacy_config: Optional["PrivacyConfig"] = None,
     ):
         """
         Initialize a file-based run context.
@@ -208,6 +247,9 @@ class FileRunContext:
             metadata: Run metadata
             tool_registry: Registry of available tools
             on_event: Optional callback for events
+            system_context: Optional SystemContext for multi-agent systems with shared knowledge
+            user_context: Optional UserContext for user isolation and privacy
+            privacy_config: Optional PrivacyConfig for privacy settings (defaults to max privacy)
         """
         self._run_id = run_id or uuid4()
         self._checkpoint_dir = Path(checkpoint_dir)
@@ -219,6 +261,17 @@ class FileRunContext:
         self._cancelled = False
         self._on_event = on_event
         self._state_cache: Optional[dict] = None
+        self._system_context = system_context
+
+        # Import here to avoid circular imports
+        from agent_runtime_core.privacy import (
+            DEFAULT_PRIVACY_CONFIG,
+            ANONYMOUS_USER,
+        )
+
+        # Default to secure settings: anonymous user + strict privacy
+        self._user_context = user_context if user_context is not None else ANONYMOUS_USER
+        self._privacy_config = privacy_config if privacy_config is not None else DEFAULT_PRIVACY_CONFIG
 
         # Ensure checkpoint directory exists
         self._checkpoint_dir.mkdir(parents=True, exist_ok=True)
@@ -253,6 +306,21 @@ class FileRunContext:
         """Registry of available tools for this agent."""
         return self._tool_registry
 
+    @property
+    def system_context(self) -> Optional["SystemContext"]:
+        """System context for multi-agent systems with shared knowledge."""
+        return self._system_context
+
+    @property
+    def user_context(self) -> "UserContext":
+        """User context for privacy and data isolation. Defaults to ANONYMOUS_USER."""
+        return self._user_context
+
+    @property
+    def privacy_config(self) -> "PrivacyConfig":
+        """Privacy configuration for this run. Defaults to DEFAULT_PRIVACY_CONFIG (strict)."""
+        return self._privacy_config
+
     def _checkpoint_path(self) -> Path:
         """Get the path to the checkpoint file for this run."""
         return self._checkpoint_dir / f"{self._run_id}.json"

agent_runtime_core/files/__init__.py

@@ -0,0 +1,88 @@
+"""
+File processing module for agent_runtime_core.
+
+Provides pluggable file processors for reading various file types,
+OCR integration, and AI vision capabilities.
+
+Example:
+    from agent_runtime_core.files import FileProcessorRegistry, process_file
+    
+    # Register processors
+    registry = FileProcessorRegistry()
+    registry.auto_register()  # Register all available processors
+    
+    # Process a file
+    result = await registry.process("document.pdf", file_bytes)
+    print(result.text)  # Extracted text
+    print(result.metadata)  # File metadata
+"""
+
+from .base import (
+    FileProcessor,
+    FileProcessorRegistry,
+    ProcessedFile,
+    FileType,
+    ProcessingOptions,
+)
+from .processors import (
+    TextFileProcessor,
+    PDFProcessor,
+    ImageProcessor,
+    DocxProcessor,
+    XlsxProcessor,
+    CsvProcessor,
+)
+from .ocr import (
+    OCRProvider,
+    TesseractOCR,
+    GoogleVisionOCR,
+    AWSTextractOCR,
+    AzureDocumentOCR,
+)
+from .vision import (
+    VisionProvider,
+    OpenAIVision,
+    AnthropicVision,
+    GeminiVision,
+)
+from .tools import (
+    FileTools,
+    FileToolsConfig,
+    get_file_read_schema,
+    get_file_write_schema,
+    get_file_list_schema,
+)
+
+__all__ = [
+    # Base classes
+    "FileProcessor",
+    "FileProcessorRegistry",
+    "ProcessedFile",
+    "FileType",
+    "ProcessingOptions",
+    # Processors
+    "TextFileProcessor",
+    "PDFProcessor",
+    "ImageProcessor",
+    "DocxProcessor",
+    "XlsxProcessor",
+    "CsvProcessor",
+    # OCR
+    "OCRProvider",
+    "TesseractOCR",
+    "GoogleVisionOCR",
+    "AWSTextractOCR",
+    "AzureDocumentOCR",
+    # Vision
+    "VisionProvider",
+    "OpenAIVision",
+    "AnthropicVision",
+    "GeminiVision",
+    # Tools
+    "FileTools",
+    "FileToolsConfig",
+    "get_file_read_schema",
+    "get_file_write_schema",
+    "get_file_list_schema",
+]
+

agent_runtime_core/files/base.py

@@ -0,0 +1,343 @@
+"""
+Base classes for file processing.
+
+Provides the FileProcessor abstract base class and registry pattern
+for pluggable file type handling.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Optional, Type, Union
+import mimetypes
+
+
+class FileType(str, Enum):
+    """Supported file types."""
+    TEXT = "text"
+    PDF = "pdf"
+    IMAGE = "image"
+    DOCX = "docx"
+    XLSX = "xlsx"
+    CSV = "csv"
+    JSON = "json"
+    MARKDOWN = "markdown"
+    HTML = "html"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class ProcessingOptions:
+    """Options for file processing."""
+    # General options
+    max_size_bytes: int = 100 * 1024 * 1024  # 100MB default
+    extract_text: bool = True
+    extract_metadata: bool = True
+    
+    # OCR options
+    use_ocr: bool = False
+    ocr_provider: Optional[str] = None  # tesseract, google, aws, azure
+    ocr_language: str = "eng"
+    
+    # Vision AI options
+    use_vision: bool = False
+    vision_provider: Optional[str] = None  # openai, anthropic, gemini
+    vision_prompt: Optional[str] = None  # Custom prompt for vision analysis
+    
+    # Image options
+    generate_thumbnail: bool = True
+    thumbnail_size: tuple[int, int] = (200, 200)
+    
+    # PDF options
+    pdf_extract_images: bool = False
+    pdf_page_limit: Optional[int] = None  # Limit pages to process
+    
+    # Additional provider-specific options
+    extra: dict = field(default_factory=dict)
+
+
+@dataclass
+class ProcessedFile:
+    """Result of processing a file."""
+    # Core data
+    filename: str
+    file_type: FileType
+    mime_type: str
+    size_bytes: int
+    
+    # Extracted content
+    text: str = ""
+    text_chunks: list[str] = field(default_factory=list)  # For chunked processing
+    
+    # Metadata
+    metadata: dict = field(default_factory=dict)
+    
+    # Visual data
+    thumbnail_base64: Optional[str] = None
+    preview_url: Optional[str] = None
+    
+    # OCR/Vision results
+    ocr_text: Optional[str] = None
+    vision_description: Optional[str] = None
+    vision_analysis: Optional[dict] = None
+    
+    # Processing info
+    processor_used: str = ""
+    processing_time_ms: float = 0
+    warnings: list[str] = field(default_factory=list)
+    
+    # Raw data (optional, for further processing)
+    raw_content: Optional[bytes] = None
+
+
+class FileProcessor(ABC):
+    """
+    Abstract base class for file processors.
+    
+    Subclass this to create processors for specific file types.
+    Each processor declares which file types and MIME types it handles.
+    """
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Unique name for this processor."""
+        ...
+    
+    @property
+    @abstractmethod
+    def supported_types(self) -> list[FileType]:
+        """List of FileType enums this processor handles."""
+        ...
+    
+    @property
+    @abstractmethod
+    def supported_extensions(self) -> list[str]:
+        """List of file extensions this processor handles (e.g., ['.pdf', '.PDF'])."""
+        ...
+    
+    @property
+    def supported_mime_types(self) -> list[str]:
+        """List of MIME types this processor handles. Override if needed."""
+        return []
+    
+    @abstractmethod
+    async def process(
+        self,
+        content: bytes,
+        filename: str,
+        options: ProcessingOptions,
+    ) -> ProcessedFile:
+        """
+        Process file content and extract text/metadata.
+        
+        Args:
+            content: Raw file bytes
+            filename: Original filename
+            options: Processing options
+            
+        Returns:
+            ProcessedFile with extracted content
+        """
+        ...
+    
+    def can_process(self, filename: str, mime_type: Optional[str] = None) -> bool:
+        """Check if this processor can handle the given file."""
+        ext = Path(filename).suffix.lower()
+        if ext in [e.lower() for e in self.supported_extensions]:
+            return True
+        if mime_type and mime_type in self.supported_mime_types:
+            return True
+        return False
+
+
+class FileProcessorRegistry:
+    """
+    Registry of file processors.
+    
+    Manages processor registration and selection based on file type.
+    """
+    
+    def __init__(self):
+        self._processors: dict[str, FileProcessor] = {}
+        self._type_map: dict[FileType, list[str]] = {}
+        self._extension_map: dict[str, str] = {}
+    
+    def register(self, processor: FileProcessor) -> None:
+        """Register a file processor."""
+        self._processors[processor.name] = processor
+        
+        # Map file types to processor
+        for file_type in processor.supported_types:
+            if file_type not in self._type_map:
+                self._type_map[file_type] = []
+            self._type_map[file_type].append(processor.name)
+        
+        # Map extensions to processor
+        for ext in processor.supported_extensions:
+            self._extension_map[ext.lower()] = processor.name
+
+    def get(self, name: str) -> Optional[FileProcessor]:
+        """Get a processor by name."""
+        return self._processors.get(name)
+
+    def get_for_file(
+        self,
+        filename: str,
+        mime_type: Optional[str] = None,
+    ) -> Optional[FileProcessor]:
+        """Get the best processor for a file."""
+        ext = Path(filename).suffix.lower()
+
+        # Try extension first
+        if ext in self._extension_map:
+            return self._processors[self._extension_map[ext]]
+
+        # Try MIME type
+        if mime_type:
+            for processor in self._processors.values():
+                if mime_type in processor.supported_mime_types:
+                    return processor
+
+        # Guess MIME type from filename
+        guessed_mime, _ = mimetypes.guess_type(filename)
+        if guessed_mime:
+            for processor in self._processors.values():
+                if guessed_mime in processor.supported_mime_types:
+                    return processor
+
+        return None
+
+    async def process(
+        self,
+        filename: str,
+        content: bytes,
+        options: Optional[ProcessingOptions] = None,
+        mime_type: Optional[str] = None,
+    ) -> ProcessedFile:
+        """
+        Process a file using the appropriate processor.
+
+        Args:
+            filename: Original filename
+            content: Raw file bytes
+            options: Processing options (uses defaults if not provided)
+            mime_type: Optional MIME type hint
+
+        Returns:
+            ProcessedFile with extracted content
+
+        Raises:
+            ValueError: If no processor found for file type
+            ValueError: If file exceeds size limit
+        """
+        if options is None:
+            options = ProcessingOptions()
+
+        # Check size limit
+        if len(content) > options.max_size_bytes:
+            raise ValueError(
+                f"File size ({len(content)} bytes) exceeds limit "
+                f"({options.max_size_bytes} bytes)"
+            )
+
+        # Find processor
+        processor = self.get_for_file(filename, mime_type)
+        if not processor:
+            raise ValueError(f"No processor found for file: {filename}")
+
+        # Process
+        return await processor.process(content, filename, options)
+
+    def list_processors(self) -> list[FileProcessor]:
+        """List all registered processors."""
+        return list(self._processors.values())
+
+    def supported_extensions(self) -> list[str]:
+        """List all supported file extensions."""
+        return list(self._extension_map.keys())
+
+    def auto_register(self) -> None:
+        """
+        Auto-register all available processors.
+
+        Registers built-in processors and checks for optional dependencies.
+        """
+        from .processors import (
+            TextFileProcessor,
+            PDFProcessor,
+            ImageProcessor,
+            DocxProcessor,
+            XlsxProcessor,
+            CsvProcessor,
+        )
+
+        # Always available
+        self.register(TextFileProcessor())
+        self.register(CsvProcessor())
+
+        # Check for optional dependencies
+        try:
+            import pypdf
+            self.register(PDFProcessor())
+        except ImportError:
+            pass
+
+        try:
+            from PIL import Image
+            self.register(ImageProcessor())
+        except ImportError:
+            pass
+
+        try:
+            import docx
+            self.register(DocxProcessor())
+        except ImportError:
+            pass
+
+        try:
+            import openpyxl
+            self.register(XlsxProcessor())
+        except ImportError:
+            pass
+
+
+def detect_file_type(filename: str, content: Optional[bytes] = None) -> FileType:
+    """
+    Detect file type from filename and optionally content.
+
+    Args:
+        filename: Filename with extension
+        content: Optional file content for magic number detection
+
+    Returns:
+        Detected FileType
+    """
+    ext = Path(filename).suffix.lower()
+
+    extension_map = {
+        ".txt": FileType.TEXT,
+        ".text": FileType.TEXT,
+        ".log": FileType.TEXT,
+        ".pdf": FileType.PDF,
+        ".png": FileType.IMAGE,
+        ".jpg": FileType.IMAGE,
+        ".jpeg": FileType.IMAGE,
+        ".gif": FileType.IMAGE,
+        ".webp": FileType.IMAGE,
+        ".bmp": FileType.IMAGE,
+        ".docx": FileType.DOCX,
+        ".doc": FileType.DOCX,
+        ".xlsx": FileType.XLSX,
+        ".xls": FileType.XLSX,
+        ".csv": FileType.CSV,
+        ".json": FileType.JSON,
+        ".md": FileType.MARKDOWN,
+        ".markdown": FileType.MARKDOWN,
+        ".html": FileType.HTML,
+        ".htm": FileType.HTML,
+    }
+
+    return extension_map.get(ext, FileType.UNKNOWN)
+