jaf-py 2.4.1__py3-none-any.whl → 2.4.2__py3-none-any.whl

jaf/utils/document_processor.py

@@ -0,0 +1,561 @@
+"""
+Document processing utilities for the JAF framework.
+
+This module provides robust document content extraction with support for various
+formats including PDF, Word documents, Excel spreadsheets, and more.
+"""
+
+import asyncio
+import base64
+import csv
+import io
+import json
+import zipfile
+from typing import Dict, Any, Optional, List
+
+try:
+    import aiofiles
+    HAS_AIOFILES = True
+except ImportError:
+    HAS_AIOFILES = False
+
+try:
+    import httpx
+    HAS_HTTPX = True
+except ImportError:
+    HAS_HTTPX = False
+from pydantic import BaseModel
+
+from ..core.types import Attachment
+
+# Optional imports with graceful fallbacks
+try:
+    import PyPDF2
+    HAS_PDF = True
+except ImportError:
+    HAS_PDF = False
+
+try:
+    from docx import Document
+    HAS_DOCX = True
+except ImportError:
+    HAS_DOCX = False
+
+try:
+    from openpyxl import load_workbook
+    HAS_EXCEL = True
+except ImportError:
+    HAS_EXCEL = False
+
+try:
+    import magic
+    HAS_MAGIC = True
+except ImportError:
+    HAS_MAGIC = False
+
+try:
+    from PIL import Image
+    HAS_PIL = True
+except ImportError:
+    HAS_PIL = False
+
+
+# Constants
+FETCH_TIMEOUT = 30.0
+MAX_DOCUMENT_SIZE = 25 * 1024 * 1024  # 25MB
+MAX_CSV_PREVIEW_ROWS = 10
+MAX_EXCEL_SHEETS = 3
+MAX_EXCEL_ROWS_PER_SHEET = 20
+
+
+class DocumentProcessingError(Exception):
+    """Exception raised when document processing fails."""
+    
+    def __init__(self, message: str, cause: Optional[Exception] = None):
+        super().__init__(message)
+        self.cause = cause
+
+
+class NetworkError(Exception):
+    """Exception raised when network operations fail."""
+    
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class ProcessedDocument(BaseModel):
+    """Result of document processing."""
+    content: str
+    metadata: Optional[Dict[str, Any]] = None
+
+
+async def _fetch_url_content(url: str) -> tuple[bytes, Optional[str]]:
+    """
+    Fetch content from URL and return as bytes with content type.
+    
+    Args:
+        url: URL to fetch
+        
+    Returns:
+        Tuple of (content_bytes, content_type)
+        
+    Raises:
+        NetworkError: If fetch fails
+        DocumentProcessingError: If file is too large
+    """
+    if not HAS_HTTPX:
+        raise DocumentProcessingError(
+            "URL fetching not available. Install with: pip install 'jaf-py[attachments]'"
+        )
+    
+    try:
+        async with httpx.AsyncClient(timeout=FETCH_TIMEOUT) as client:
+            # First check content length with a HEAD request if possible
+            try:
+                head_response = await client.head(
+                    url,
+                    headers={'User-Agent': 'JAF-DocumentProcessor/1.0'},
+                    timeout=FETCH_TIMEOUT / 2  # Shorter timeout for HEAD request
+                )
+                head_response.raise_for_status()
+                
+                # Check Content-Length header if present
+                content_length_str = head_response.headers.get('content-length')
+                if content_length_str and content_length_str.isdigit():
+                    content_length = int(content_length_str)
+                    if content_length > MAX_DOCUMENT_SIZE:
+                        size_mb = round(content_length / 1024 / 1024)
+                        max_mb = round(MAX_DOCUMENT_SIZE / 1024 / 1024)
+                        raise DocumentProcessingError(
+                            f"File size ({size_mb}MB) exceeds maximum allowed size ({max_mb}MB)"
+                        )
+            except (httpx.HTTPStatusError, httpx.RequestError):
+                # HEAD request failed, we'll check size during streaming
+                pass
+            
+            # Stream the response to validate size as we download
+            content_type = None
+            accumulated_bytes = bytearray()
+            async with client.stream(
+                'GET',
+                url,
+                headers={'User-Agent': 'JAF-DocumentProcessor/1.0'}
+            ) as response:
+                response.raise_for_status()
+                content_type = response.headers.get('content-type')
+                
+                # Process the response in chunks
+                async for chunk in response.aiter_bytes(chunk_size=8192):
+                    accumulated_bytes.extend(chunk)
+                    if len(accumulated_bytes) > MAX_DOCUMENT_SIZE:
+                        size_mb = round(len(accumulated_bytes) / 1024 / 1024)
+                        max_mb = round(MAX_DOCUMENT_SIZE / 1024 / 1024)
+                        raise DocumentProcessingError(
+                            f"File size ({size_mb}MB) exceeds maximum allowed size ({max_mb}MB)"
+                        )
+            
+            return bytes(accumulated_bytes), content_type
+            
+    except httpx.HTTPStatusError as e:
+        raise NetworkError(f"HTTP {e.response.status_code}: {e.response.reason_phrase}", e.response.status_code)
+    except httpx.RequestError as e:
+        raise NetworkError(f"Failed to fetch URL content: {e}", cause=e)
+    except Exception as e:
+        # Preserve system exceptions
+        if isinstance(e, (KeyboardInterrupt, SystemExit, GeneratorExit, MemoryError)):
+            raise
+        raise NetworkError(f"Failed to fetch URL content: {e}", cause=e)
+
+
+async def extract_document_content(attachment: Attachment) -> ProcessedDocument:
+    """
+    Extract text content from various document formats.
+    
+    Args:
+        attachment: Attachment to process
+        
+    Returns:
+        ProcessedDocument with extracted content
+        
+    Raises:
+        DocumentProcessingError: If processing fails
+    """
+    # Get content as bytes
+    if attachment.url and not attachment.data:
+        content_bytes, detected_mime_type = await _fetch_url_content(attachment.url)
+        mime_type = attachment.mime_type or detected_mime_type
+    elif attachment.data:
+        content_bytes = base64.b64decode(attachment.data)
+        mime_type = attachment.mime_type
+    else:
+        raise DocumentProcessingError('No document data or URL provided')
+    
+    # Normalize MIME type
+    mime_type = mime_type.lower() if mime_type else None
+    
+    # Process based on MIME type
+    if mime_type == 'application/pdf':
+        return await _extract_pdf_content(content_bytes)
+    elif mime_type in ['application/vnd.openxmlformats-officedocument.wordprocessingml.document']:
+        return _extract_docx_content(content_bytes)
+    elif mime_type in ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', 'application/vnd.ms-excel']:
+        return _extract_excel_content(content_bytes)
+    elif mime_type == 'application/json':
+        return _extract_json_content(content_bytes)
+    elif mime_type == 'application/zip':
+        return _extract_zip_content(content_bytes)
+    elif mime_type in ['text/plain', 'text/csv']:
+        return _extract_text_content(content_bytes, mime_type)
+    else:
+        # Fallback: try to extract as text
+        return _extract_text_content(content_bytes, 'text/plain')
+
+
+async def _extract_pdf_content(content_bytes: bytes) -> ProcessedDocument:
+    """Extract content from PDF."""
+    if not HAS_PDF:
+        raise DocumentProcessingError(
+            "PDF processing not available. Install with: pip install 'jaf-py[attachments]'"
+        )
+    
+    try:
+        # Run PDF processing in thread pool to avoid blocking
+        def _process_pdf() -> ProcessedDocument:
+            reader = PyPDF2.PdfReader(io.BytesIO(content_bytes))
+            text_parts = []
+            
+            for page in reader.pages:
+                text_parts.append(page.extract_text())
+            
+            content = '\n'.join(text_parts).strip()
+            
+            return ProcessedDocument(
+                content=content,
+                metadata={
+                    'pages': len(reader.pages),
+                    'info': dict(reader.metadata) if reader.metadata else None
+                }
+            )
+        
+        return await asyncio.get_event_loop().run_in_executor(None, _process_pdf)
+        
+    except Exception as e:
+        raise DocumentProcessingError(f"Failed to extract PDF content: {e}") from e
+
+
+def _extract_text_content(content_bytes: bytes, mime_type: str) -> ProcessedDocument:
+    """Extract content from text files."""
+    try:
+        content = content_bytes.decode('utf-8').strip()
+        
+        if mime_type == 'text/csv':
+            # Parse CSV to provide structured overview
+            try:
+                csv_reader = csv.DictReader(io.StringIO(content))
+                rows = list(csv_reader)
+                columns = csv_reader.fieldnames or []
+                
+                content_lines = content.split('\n')
+                preview_lines = content_lines[:MAX_CSV_PREVIEW_ROWS]
+                
+                formatted_content = (
+                    f"CSV File Content:\n"
+                    f"Rows: {len(rows)}, Columns: {len(columns)}\n"
+                    f"Columns: {', '.join(columns)}\n\n"
+                    f"First few rows:\n{chr(10).join(preview_lines)}"
+                )
+                
+                return ProcessedDocument(
+                    content=formatted_content,
+                    metadata={
+                        'rows': len(rows),
+                        'columns': len(columns),
+                        'fields': columns
+                    }
+                )
+            except Exception:
+                # Fallback to raw text if CSV parsing fails
+                pass
+        
+        return ProcessedDocument(content=content)
+        
+    except UnicodeDecodeError as e:
+        raise DocumentProcessingError(f"Failed to decode text content: {e}") from e
+
+
+def _extract_excel_content(content_bytes: bytes) -> ProcessedDocument:
+    """Extract content from Excel files."""
+    if not HAS_EXCEL:
+        raise DocumentProcessingError(
+            "Excel processing not available. Install with: pip install 'jaf-py[attachments]'"
+        )
+    
+    try:
+        workbook = load_workbook(io.BytesIO(content_bytes), read_only=True)
+        sheet_names = workbook.sheetnames
+        
+        content_parts = [f"Excel File Content:\nSheets: {', '.join(sheet_names)}\n"]
+        
+        # Extract content from each sheet (limit to avoid overwhelming output)
+        for i, sheet_name in enumerate(sheet_names):
+            if i >= MAX_EXCEL_SHEETS:
+                break
+                
+            worksheet = workbook[sheet_name]
+            content_parts.append(f"\nSheet: {sheet_name}")
+            
+            # Extract up to MAX_EXCEL_ROWS_PER_SHEET rows
+            rows_data = []
+            for row_num, row in enumerate(worksheet.iter_rows(values_only=True), 1):
+                if row_num > MAX_EXCEL_ROWS_PER_SHEET:
+                    break
+                # Convert row to strings, handling None values
+                row_strings = [str(cell) if cell is not None else '' for cell in row]
+                rows_data.append(','.join(row_strings))
+            
+            content_parts.append('\n'.join(rows_data))
+        
+        content = '\n'.join(content_parts).strip()
+        
+        return ProcessedDocument(
+            content=content,
+            metadata={'sheets': sheet_names}
+        )
+        
+    except Exception as e:
+        raise DocumentProcessingError(f"Failed to extract Excel content: {e}") from e
+
+
+def _extract_docx_content(content_bytes: bytes) -> ProcessedDocument:
+    """Extract content from Word documents."""
+    if not HAS_DOCX:
+        raise DocumentProcessingError(
+            "Word document processing not available. Install with: pip install 'jaf-py[attachments]'"
+        )
+    
+    try:
+        document = Document(io.BytesIO(content_bytes))
+        paragraphs = [paragraph.text for paragraph in document.paragraphs]
+        content = '\n'.join(paragraphs).strip()
+        
+        return ProcessedDocument(
+            content=content,
+            metadata={'paragraphs': len(paragraphs)}
+        )
+        
+    except Exception as e:
+        raise DocumentProcessingError(f"Failed to extract DOCX content: {e}") from e
+
+
+def _extract_json_content(content_bytes: bytes) -> ProcessedDocument:
+    """Extract content from JSON files."""
+    try:
+        json_str = content_bytes.decode('utf-8')
+        json_obj = json.loads(json_str)
+        
+        # Pretty print JSON with some metadata
+        formatted_content = f"JSON File Content:\n{json.dumps(json_obj, indent=2)}"
+        
+        metadata = {
+            'type': 'array' if isinstance(json_obj, list) else type(json_obj).__name__
+        }
+        
+        if isinstance(json_obj, dict):
+            metadata['keys'] = list(json_obj.keys())
+        elif isinstance(json_obj, list):
+            metadata['length'] = len(json_obj)
+        
+        return ProcessedDocument(
+            content=formatted_content,
+            metadata=metadata
+        )
+        
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        # Fallback to raw text if JSON parsing fails
+        if isinstance(content_bytes, bytes):
+            # If input is bytes, decode with error handling
+            fallback_content = content_bytes.decode('utf-8', errors='replace').strip()
+        else:
+            # If input is already a string (from a previous decode attempt)
+            fallback_content = json_str.strip() if isinstance(json_str, str) else str(content_bytes)
+        
+        return ProcessedDocument(content=fallback_content)
+
+
+def _extract_zip_content(content_bytes: bytes) -> ProcessedDocument:
+    """Extract file listing from ZIP archives."""
+    try:
+        with zipfile.ZipFile(io.BytesIO(content_bytes), 'r') as zip_file:
+            files = zip_file.namelist()
+            
+            content_parts = ['ZIP File Contents:\n']
+            safe_files = []
+            
+            # Create virtual root for path safety checks
+            from pathlib import Path
+            import os
+            virtual_root = Path("/safe_extract_dir")  # Virtual root never actually used for extraction
+            
+            for file_name in files:
+                # Skip empty entries
+                if not file_name:
+                    continue
+                    
+                # Basic security checks
+                if (file_name.startswith('/') or  # Absolute path
+                    file_name.startswith('\\') or  # Windows absolute path
+                    file_name.startswith('..') or  # Parent directory traversal
+                    '..' in file_name.split('/') or  # Parent directory traversal
+                    '..' in file_name.split('\\') or  # Windows traversal
+                    ':' in file_name or  # Windows drive letter
+                    '\0' in file_name):  # Null byte
+                    # Skip unsafe entries
+                    content_parts.append(f"WARNING: Skipped suspicious path: {file_name[:50]}...")
+                    continue
+                
+                # Normalize path for additional safety check
+                try:
+                    # Create safe path relative to virtual root
+                    norm_path = os.path.normpath(file_name)
+                    if norm_path.startswith('..'):
+                        # Skip unsafe entries that normalize to traversal
+                        content_parts.append(f"WARNING: Skipped path traversal attempt: {file_name[:50]}...")
+                        continue
+                    
+                    # Check if path would escape the virtual root
+                    test_path = virtual_root.joinpath(norm_path).resolve()
+                    if not str(test_path).startswith(str(virtual_root)):
+                        # Skip unsafe entries that would escape extraction root
+                        content_parts.append(f"WARNING: Skipped path traversal attempt: {file_name[:50]}...")
+                        continue
+                        
+                    # Passed all security checks, add to safe file list
+                    safe_files.append(file_name)
+                    
+                    # Get file info for display
+                    if file_name.endswith('/'):
+                        content_parts.append(f"DIR: {file_name}")
+                    else:
+                        try:
+                            file_info = zip_file.getinfo(file_name)
+                            size = file_info.file_size
+                            content_parts.append(f"FILE: {file_name} ({size} bytes)")
+                        except KeyError:
+                            content_parts.append(f"FILE: {file_name}")
+                except Exception:
+                    # Skip any entry that causes normalization errors
+                    content_parts.append(f"WARNING: Skipped invalid path: {file_name[:50]}...")
+                    continue
+            
+            content = '\n'.join(content_parts).strip()
+            
+            return ProcessedDocument(
+                content=content,
+                metadata={
+                    'files': safe_files,
+                    'total_files': len(safe_files)
+                }
+            )
+            
+    except Exception as e:
+        raise DocumentProcessingError(f"Failed to process ZIP file: {e}") from e
+
+
+def is_document_supported(mime_type: Optional[str]) -> bool:
+    """
+    Check if a MIME type is supported for content extraction.
+    
+    Args:
+        mime_type: MIME type to check
+        
+    Returns:
+        True if supported, False otherwise
+    """
+    if not mime_type:
+        return False
+    
+    supported_types = [
+        'application/pdf',
+        'text/plain',
+        'text/csv',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'application/vnd.ms-excel',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'application/json',
+        'application/zip'
+    ]
+    
+    return mime_type.lower() in supported_types
+
+
+def get_document_description(mime_type: Optional[str]) -> str:
+    """
+    Get a human-readable description of what content will be extracted.
+    
+    Args:
+        mime_type: MIME type to describe
+        
+    Returns:
+        Human-readable description
+    """
+    if not mime_type:
+        return 'document content'
+    
+    descriptions = {
+        'application/pdf': 'PDF text content',
+        'text/plain': 'plain text content',
+        'text/csv': 'CSV data structure and sample rows',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'Excel spreadsheet data',
+        'application/vnd.ms-excel': 'Excel spreadsheet data',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'Word document text content',
+        'application/json': 'JSON data structure',
+        'application/zip': 'ZIP file listing'
+    }
+    
+    return descriptions.get(mime_type.lower(), 'document content')
+
+
+def get_missing_dependencies() -> List[str]:
+    """
+    Get list of missing optional dependencies for document processing.
+    
+    Returns:
+        List of missing dependency names
+    """
+    missing = []
+    
+    if not HAS_PDF:
+        missing.append('PyPDF2 (for PDF processing)')
+    if not HAS_DOCX:
+        missing.append('python-docx (for Word document processing)')
+    if not HAS_EXCEL:
+        missing.append('openpyxl (for Excel processing)')
+    if not HAS_PIL:
+        missing.append('Pillow (for image processing)')
+    if not HAS_MAGIC:
+        missing.append('python-magic (for MIME type detection)')
+    if not HAS_HTTPX:
+        missing.append('httpx (for URL fetching)')
+    if not HAS_AIOFILES:
+        missing.append('aiofiles (for async file operations)')
+    
+    return missing
+
+
+def check_dependencies() -> Dict[str, bool]:
+    """
+    Check availability of optional dependencies.
+    
+    Returns:
+        Dictionary mapping dependency names to availability
+    """
+    return {
+        'pdf': HAS_PDF,
+        'docx': HAS_DOCX,
+        'excel': HAS_EXCEL,
+        'image': HAS_PIL,
+        'magic': HAS_MAGIC,
+        'httpx': HAS_HTTPX,
+        'aiofiles': HAS_AIOFILES
+    }

{jaf_py-2.4.1.dist-info → jaf_py-2.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.4.1
+Version: 2.4.2
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -48,6 +48,14 @@ Requires-Dist: opentelemetry-api>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-sdk>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-exporter-otlp>=1.22.0; extra == "tracing"
 Requires-Dist: langfuse<3.0.0; extra == "tracing"
+Provides-Extra: attachments
+Requires-Dist: PyPDF2>=3.0.0; extra == "attachments"
+Requires-Dist: python-docx>=1.1.0; extra == "attachments"
+Requires-Dist: openpyxl>=3.1.0; extra == "attachments"
+Requires-Dist: pillow>=11.0.0; extra == "attachments"
+Requires-Dist: python-magic>=0.4.27; sys_platform != "win32" and extra == "attachments"
+Requires-Dist: python-magic-bin>=0.4.14; sys_platform == "win32" and extra == "attachments"
+Requires-Dist: aiofiles>=23.0.0; extra == "attachments"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -66,7 +74,7 @@ Requires-Dist: psycopg2-binary>=2.9.0; extra == "memory"
 Provides-Extra: visualization
 Requires-Dist: graphviz>=0.20.0; extra == "visualization"
 Provides-Extra: all
-Requires-Dist: jaf-py[dev,memory,server,tracing,visualization]; extra == "all"
+Requires-Dist: jaf-py[attachments,dev,memory,server,tracing,visualization]; extra == "all"
 Dynamic: license-file
 
 # JAF (Juspay Agent Framework) - Python Implementation

{jaf_py-2.4.1.dist-info → jaf_py-2.4.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-jaf/__init__.py,sha256=JO-LHWJOF9IFGiQ9G4dk3Q2pFe2Wuqi5D3rA8E-W_1E,7859
+jaf/__init__.py,sha256=kNxEp8Gr_lmJheZWRbjukSFjJX9K7RBOzAzTM690N7Y,8260
 jaf/cli.py,sha256=Af4di_NZ7rZ4wFl0R4EZh611NgJ--TL03vNyZ2M1_FY,8477
 jaf/exceptions.py,sha256=nl8JY355u7oTXB3PmC_LhnUaL8fzk2K4EaWM4fVpMPE,9196
 jaf/a2a/__init__.py,sha256=p4YVthZH0ow1ZECqWTQ0aQl8JWySYZb25jlzZJ09na4,7662
@@ -39,24 +39,26 @@ jaf/a2a/tests/test_integration.py,sha256=I7LdgwN99mAOljM9kYtK7dGMMntTSWKMw_oLOcJ
 jaf/a2a/tests/test_protocol.py,sha256=He3vGlBfIazpppAnuSybutrvjIN3VGxEleAohrVd9hc,23287
 jaf/a2a/tests/test_types.py,sha256=PgRjDVJrHSXuu05z0B5lsSUUY5qEdQLFJbLBIExyVgI,18384
 jaf/core/__init__.py,sha256=rBvP_7TGbJICDJnA7a3qyX8yQErCDWaGAn5WzpyH4gU,1339
-jaf/core/agent_tool.py,sha256=8TcBuSxGmDTW5F_GhBU_m5S43nYqkjO4qTrNERraAig,11656
-jaf/core/analytics.py,sha256=NrUfOLLTDIhOzdfc65ZqS9AJ4ZAP9BtNtga69q0YdYw,23265
+jaf/core/agent_tool.py,sha256=tfLNaTIcOZ0dR9GBP1AHLPkLExm_dLbURnVIN4R84FQ,11806
+jaf/core/analytics.py,sha256=zFHIWqWal0bbEFCmJDc4DKeM0Ja7b_D19PqVaBI12pA,23338
 jaf/core/composition.py,sha256=IVxRO1Q9nK7JRH32qQ4p8WMIUu66BhqPNrlTNMGFVwE,26317
-jaf/core/engine.py,sha256=lsmvVDpmuyo7akALplvJvZvOonSzClCG-0EGbc7o5yQ,32061
+jaf/core/engine.py,sha256=uijM1N-W-OG1oelMtV4m-o2cdrBziLU75jn8JOZBaWA,50631
 jaf/core/errors.py,sha256=5fwTNhkojKRQ4wZj3lZlgDnAsrYyjYOwXJkIr5EGNUc,5539
 jaf/core/performance.py,sha256=jedQmTEkrKMD6_Aw1h8PdG-5TsdYSFFT7Or6k5dmN2g,9974
 jaf/core/proxy.py,sha256=_WM3cpRlSQLYpgSBrnY30UPMe2iZtlqDQ65kppE-WY0,4609
 jaf/core/proxy_helpers.py,sha256=i7a5fAX9rLmO4FMBX51-yRkTFwfWedzQNgnLmeLUd_A,4370
+jaf/core/state.py,sha256=NMtYTpUYa64m1Kte6lD8LGnF2bl69HAcdgXH6f-M97c,5650
 jaf/core/streaming.py,sha256=c5o9iqpjoYV2LrUpG6qLWCYrWcP-DCcZsvMbyqKunp8,16089
 jaf/core/tool_results.py,sha256=-bTOqOX02lMyslp5Z4Dmuhx0cLd5o7kgR88qK2HO_sw,11323
 jaf/core/tools.py,sha256=84N9A7QQ3xxcOs2eUUot3nmCnt5i7iZT9VwkuzuFBxQ,16274
-jaf/core/tracing.py,sha256=3ByTbpYMWHJku-NEasK5ncyMOdv7vHwmG6ybJP19pxE,31659
-jaf/core/types.py,sha256=SdtvjBNdjyvKGvGpGeUMUnYVGMpriy3QnCHUwPkz3Sg,18596
+jaf/core/tracing.py,sha256=pOswPTvhIYXj88kxMSJDySfbcnROU3eB4dooVl1e_18,36604
+jaf/core/types.py,sha256=_e7F368BwzdZ2BZuakSp5Bw7gzi8xYD0LlOIy2S25Ds,23061
 jaf/core/workflows.py,sha256=Ul-82gzjIXtkhnSMSPv-8igikjkMtW1EBo9yrfodtvI,26294
 jaf/memory/__init__.py,sha256=-L98xlvihurGAzF0DnXtkueDVvO_wV2XxxEwAWdAj50,1400
+jaf/memory/approval_storage.py,sha256=HHZ_b57kIthdR53QE5XNSII9xy1Cg-1cFUCSAZ8A4Rk,11083
 jaf/memory/factory.py,sha256=Fh6JyvQtCKe38DZV5-NnC9vPRCvzBgSSPFIGaX7Nt5E,2958
-jaf/memory/types.py,sha256=6XFC1yTlzwf9PF5UKuO5PlDdzj2CmGorZOXKCH4s6fk,8380
-jaf/memory/utils.py,sha256=erX-Fk7N5aZp7PpGeP7Zhk0LEbxnHNcDdEJ-4RhVRQQ,6863
+jaf/memory/types.py,sha256=rAilMYhAzJLceGkdk1U_worRTNw75ZJV5ZuXYR6oyLA,8484
+jaf/memory/utils.py,sha256=t_sH2txnbYLO_noT6ysmJfiU6lX7b_sp_g0lNQ2B61A,6881
 jaf/memory/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jaf/memory/providers/in_memory.py,sha256=5hiCumGK2c6SlEFdPAacC493JY1hDDfY1CaMxx8pS2E,12558
 jaf/memory/providers/postgres.py,sha256=pIXLnIsE9kA4IydIgBs3EZnI40t_h2HFIThr5NTZuhA,12144
@@ -68,20 +70,23 @@ jaf/policies/handoff.py,sha256=KJYYuL9T6v6DECRhnsS2Je6q4Aj9_zC5d_KBnvEnZNE,8318
 jaf/policies/validation.py,sha256=wn-7ynH10E5nk-_r1_kHIYHrBGmLX0EFr-FUTHrsxvc,10903
 jaf/providers/__init__.py,sha256=j_o-Rubr8d9tNYlFWb6fvzkxIBl3JKK_iabj9wTFia0,2114
 jaf/providers/mcp.py,sha256=WxcC8gUFpDBBYyhorMcc1jHq3xMDMBtnwyRPthfL0S0,13074
-jaf/providers/model.py,sha256=nulXAItAptJX6andlZWWGw19iVaqgloVkRzGNRvIKPk,15137
-jaf/server/__init__.py,sha256=K0vSgTfzn3oM54UX9BeAROpaksYY43mFtfjSXoQrhXA,339
+jaf/providers/model.py,sha256=NJTa-1k0EruDdLf2HS1ZdDpFJhHXzzfQyXAbJx9kZVc,25468
+jaf/server/__init__.py,sha256=fMPnLZBRm6t3yQrr7-PnoHAQ8qj9o6Z1AJLM1M6bIS0,392
 jaf/server/main.py,sha256=CTb0ywbPIq9ELfay5MKChVR7BpIQOoEbPjPfpzo2aBQ,2152
-jaf/server/server.py,sha256=o-n6dPWmlu4_v5ozVW3BTOm1b5kHBQhqRYlHh5sXL-k,8048
-jaf/server/types.py,sha256=On99oPFdCEjVFsxFqUbs3sUhlZ3sryn4dKuZgJKRdM4,4116
+jaf/server/server.py,sha256=LooAxxdeitwZHJff-UTE3L7zM6pSNqixMipOgspL5SA,38787
+jaf/server/types.py,sha256=Gg8z1bkA7IYg94lp31iB92-4VkJr9syKA41uVCfNZBc,10544
+jaf/utils/__init__.py,sha256=4Lte7HPIpmEuGvWd9lSH9gljV11wy-yNFjECPhcejAY,1236
+jaf/utils/attachments.py,sha256=9xNzzQanCwJnBR1L6P79YQtbuRupiDluDn46SYUlHok,13542
+jaf/utils/document_processor.py,sha256=FSALtq-RLMWJPmxRSDs32Nys4XAvacSbRf211-mjIeA,20150
 jaf/visualization/__init__.py,sha256=hx9Ao08C34_rCNd13ATWBkoiWLZspquD8MuPuQ4U5gE,1218
 jaf/visualization/example.py,sha256=8GN7Bi328yPhAWX-PVJUUa4NbO7cpC0QuwOaUt9Fsk4,12622
 jaf/visualization/functional_core.py,sha256=zedMDZbvjuOugWwnh6SJ2stvRNQX1Hlkb9AbtAtjZUg,6109
 jaf/visualization/graphviz.py,sha256=WTOM6UP72-lVKwI4_SAr5-GCC3ouckxHv88ypCDQWJ0,12056
 jaf/visualization/imperative_shell.py,sha256=GpMrAlMnLo2IQgyB2nardCz09vMvAzaYI46MyrvJ0i4,2593
 jaf/visualization/types.py,sha256=QQcbVeQJLuAOXk8ynd08DXIS-PVCnv3R-XVE9iAcglw,1389
-jaf_py-2.4.1.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
-jaf_py-2.4.1.dist-info/METADATA,sha256=F38_7dDyrX_DFA71FLRmSkqzfoubdyGqUT_iKAjEF5w,27216
-jaf_py-2.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jaf_py-2.4.1.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
-jaf_py-2.4.1.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
-jaf_py-2.4.1.dist-info/RECORD,,
+jaf_py-2.4.2.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
+jaf_py-2.4.2.dist-info/METADATA,sha256=P6_xWxcUBZj-5uJXZhxRU4rAIWhRc1Q_EPYC6ohASpk,27712
+jaf_py-2.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaf_py-2.4.2.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
+jaf_py-2.4.2.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
+jaf_py-2.4.2.dist-info/RECORD,,