jaf-py 2.5.10__py3-none-any.whl → 2.5.11__py3-none-any.whl

jaf/exceptions.py

@@ -21,6 +21,7 @@ class JAFException(Exception):
 # Agent and execution errors
 class AgentException(JAFException):
     """Base exception for agent-related errors."""
+
     pass
 
 
@@ -35,7 +36,9 @@ class AgentNotFoundError(AgentException):
 class HandoffError(AgentException):
     """Raised when agent handoff fails."""
 
-    def __init__(self, message: str, source_agent: Optional[str] = None, target_agent: Optional[str] = None):
+    def __init__(
+        self, message: str, source_agent: Optional[str] = None, target_agent: Optional[str] = None
+    ):
         details = {}
         if source_agent:
             details["source_agent"] = source_agent
@@ -47,6 +50,7 @@ class HandoffError(AgentException):
 # Tool execution errors
 class ToolException(JAFException):
     """Base exception for tool-related errors."""
+
     pass
 
 
@@ -54,10 +58,10 @@ class ToolExecutionError(ToolException):
     """Raised when tool execution fails."""
 
     def __init__(self, tool_name: str, message: str, cause: Optional[Exception] = None):
-        super().__init__(f"Tool '{tool_name}' execution failed: {message}", {
-            "tool_name": tool_name,
-            "cause": str(cause) if cause else None
-        })
+        super().__init__(
+            f"Tool '{tool_name}' execution failed: {message}",
+            {"tool_name": tool_name, "cause": str(cause) if cause else None},
+        )
         self.tool_name = tool_name
         self.cause = cause
 
@@ -67,10 +71,7 @@ class ToolValidationError(ToolException):
 
     def __init__(self, tool_name: str, validation_errors: List[str]):
         message = f"Tool '{tool_name}' validation failed: {'; '.join(validation_errors)}"
-        super().__init__(message, {
-            "tool_name": tool_name,
-            "validation_errors": validation_errors
-        })
+        super().__init__(message, {"tool_name": tool_name, "validation_errors": validation_errors})
         self.tool_name = tool_name
         self.validation_errors = validation_errors
 
@@ -78,6 +79,7 @@ class ToolValidationError(ToolException):
 # Model and provider errors
 class ModelException(JAFException):
     """Base exception for model-related errors."""
+
     pass
 
 
@@ -85,10 +87,10 @@ class ModelProviderError(ModelException):
     """Raised when model provider encounters an error."""
 
     def __init__(self, provider: str, message: str, status_code: Optional[int] = None):
-        super().__init__(f"Model provider '{provider}' error: {message}", {
-            "provider": provider,
-            "status_code": status_code
-        })
+        super().__init__(
+            f"Model provider '{provider}' error: {message}",
+            {"provider": provider, "status_code": status_code},
+        )
         self.provider = provider
         self.status_code = status_code
 
@@ -97,26 +99,27 @@ class ModelResponseError(ModelException):
     """Raised when model response is invalid or cannot be parsed."""
 
     def __init__(self, message: str, raw_response: Optional[str] = None):
-        super().__init__(f"Model response error: {message}", {
-            "raw_response": raw_response
-        })
+        super().__init__(f"Model response error: {message}", {"raw_response": raw_response})
         self.raw_response = raw_response
 
 
 # Validation and guardrail errors
 class ValidationException(JAFException):
     """Base exception for validation errors."""
+
     pass
 
 
 class GuardrailViolationError(ValidationException):
     """Raised when input or output violates a guardrail."""
 
-    def __init__(self, guardrail_type: str, message: str, violation_details: Optional[Dict[str, Any]] = None):
-        super().__init__(f"Guardrail violation ({guardrail_type}): {message}", {
-            "guardrail_type": guardrail_type,
-            "violation_details": violation_details or {}
-        })
+    def __init__(
+        self, guardrail_type: str, message: str, violation_details: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(
+            f"Guardrail violation ({guardrail_type}): {message}",
+            {"guardrail_type": guardrail_type, "violation_details": violation_details or {}},
+        )
         self.guardrail_type = guardrail_type
         self.violation_details = violation_details or {}
 
@@ -125,15 +128,14 @@ class InputValidationError(ValidationException):
     """Raised when input validation fails."""
 
     def __init__(self, message: str, field_errors: Optional[Dict[str, List[str]]] = None):
-        super().__init__(f"Input validation error: {message}", {
-            "field_errors": field_errors or {}
-        })
+        super().__init__(f"Input validation error: {message}", {"field_errors": field_errors or {}})
         self.field_errors = field_errors or {}
 
 
 # Memory system errors
 class MemoryException(JAFException):
     """Base exception for memory system errors."""
+
     pass
 
 
@@ -141,9 +143,7 @@ class MemoryConnectionError(MemoryException):
     """Raised when memory provider connection fails."""
 
     def __init__(self, provider: str, message: str):
-        super().__init__(f"Memory connection error ({provider}): {message}", {
-            "provider": provider
-        })
+        super().__init__(f"Memory connection error ({provider}): {message}", {"provider": provider})
         self.provider = provider
 
 
@@ -162,6 +162,7 @@ class MemoryStorageError(MemoryException):
 # Session and workflow errors
 class SessionException(JAFException):
     """Base exception for session-related errors."""
+
     pass
 
 
@@ -180,10 +181,10 @@ class MaxTurnsExceededError(SessionException):
     """Raised when maximum number of turns is exceeded."""
 
     def __init__(self, max_turns: int, current_turns: int):
-        super().__init__(f"Maximum turns exceeded: {current_turns}/{max_turns}", {
-            "max_turns": max_turns,
-            "current_turns": current_turns
-        })
+        super().__init__(
+            f"Maximum turns exceeded: {current_turns}/{max_turns}",
+            {"max_turns": max_turns, "current_turns": current_turns},
+        )
         self.max_turns = max_turns
         self.current_turns = current_turns
 
@@ -191,13 +192,16 @@ class MaxTurnsExceededError(SessionException):
 # A2A protocol errors
 class A2AException(JAFException):
     """Base exception for A2A protocol errors."""
+
     pass
 
 
 class A2AProtocolError(A2AException):
     """Raised when A2A protocol operation fails."""
 
-    def __init__(self, message: str, method: Optional[str] = None, context_id: Optional[str] = None):
+    def __init__(
+        self, message: str, method: Optional[str] = None, context_id: Optional[str] = None
+    ):
         details = {}
         if method:
             details["method"] = method
@@ -222,6 +226,7 @@ class A2ATaskError(A2AException):
 # Configuration errors
 class ConfigurationException(JAFException):
     """Base exception for configuration errors."""
+
     pass
 
 
@@ -229,10 +234,10 @@ class InvalidConfigurationError(ConfigurationException):
     """Raised when configuration is invalid."""
 
     def __init__(self, config_type: str, message: str, config_errors: Optional[List[str]] = None):
-        super().__init__(f"Invalid {config_type} configuration: {message}", {
-            "config_type": config_type,
-            "config_errors": config_errors or []
-        })
+        super().__init__(
+            f"Invalid {config_type} configuration: {message}",
+            {"config_type": config_type, "config_errors": config_errors or []},
+        )
         self.config_type = config_type
         self.config_errors = config_errors or []
 
@@ -245,7 +250,9 @@ def create_agent_error(message: str, agent_name: Optional[str] = None) -> AgentE
     return AgentException(message)
 
 
-def create_tool_error(tool_name: str, message: str, cause: Optional[Exception] = None) -> ToolException:
+def create_tool_error(
+    tool_name: str, message: str, cause: Optional[Exception] = None
+) -> ToolException:
     """Create a tool-related error."""
     if "validation" in message.lower():
         return ToolValidationError(tool_name, [message])
@@ -257,7 +264,8 @@ def create_session_error(message: str, session_id: Optional[str] = None) -> Sess
     if "max turns" in message.lower() or "maximum turns" in message.lower():
         # Extract numbers if possible
         import re
-        numbers = re.findall(r'\d+', message)
+
+        numbers = re.findall(r"\d+", message)
         if len(numbers) >= 2:
             return MaxTurnsExceededError(int(numbers[0]), int(numbers[1]))
         return MaxTurnsExceededError(10, 10)  # Default fallback

jaf/memory/__init__.py

@@ -37,29 +37,24 @@ __all__ = [
     "MemoryProvider",
     "MemoryQuery",
     "MemoryConfig",
-
     # Result types
     "Result",
     "Success",
     "Failure",
-
     # Configuration types
     "InMemoryConfig",
     "RedisConfig",
     "PostgresConfig",
     "MemoryProviderConfig",
-
     # Error types
     "MemoryError",
     "MemoryConnectionError",
     "MemoryNotFoundError",
     "MemoryStorageError",
-
     # Factory functions
     "create_memory_provider_from_env",
-
     # Provider factories
     "create_in_memory_provider",
     "create_redis_provider",
-    "create_postgres_provider"
+    "create_postgres_provider",
 ]

jaf/memory/approval_storage.py

@@ -15,19 +15,19 @@ from ..core.types import RunId, ApprovalValue
 
 class ApprovalStorageResult:
     """Result wrapper for approval storage operations."""
-    
+
     def __init__(self, success: bool, data: Any = None, error: Optional[str] = None):
         self.success = success
         self.data = data
         self.error = error
 
     @classmethod
-    def success_result(cls, data: Any = None) -> 'ApprovalStorageResult':
+    def success_result(cls, data: Any = None) -> "ApprovalStorageResult":
         """Create a successful result."""
         return cls(success=True, data=data)
 
     @classmethod
-    def error_result(cls, error: str) -> 'ApprovalStorageResult':
+    def error_result(cls, error: str) -> "ApprovalStorageResult":
         """Create an error result."""
         return cls(success=False, error=error)
 
@@ -41,44 +41,30 @@ class ApprovalStorage(ABC):
         run_id: RunId,
         tool_call_id: str,
         approval: ApprovalValue,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> ApprovalStorageResult:
         """Store an approval decision for a tool call."""
         pass
 
     @abstractmethod
-    async def get_approval(
-        self,
-        run_id: RunId,
-        tool_call_id: str
-    ) -> ApprovalStorageResult:
+    async def get_approval(self, run_id: RunId, tool_call_id: str) -> ApprovalStorageResult:
         """Retrieve approval for a specific tool call. Returns None if not found."""
         pass
 
     @abstractmethod
-    async def get_run_approvals(
-        self,
-        run_id: RunId
-    ) -> ApprovalStorageResult:
+    async def get_run_approvals(self, run_id: RunId) -> ApprovalStorageResult:
         """Get all approvals for a run as a Dict[str, ApprovalValue]."""
         pass
 
     @abstractmethod
     async def update_approval(
-        self,
-        run_id: RunId,
-        tool_call_id: str,
-        updates: Dict[str, Any]
+        self, run_id: RunId, tool_call_id: str, updates: Dict[str, Any]
     ) -> ApprovalStorageResult:
         """Update existing approval with additional context."""
         pass
 
     @abstractmethod
-    async def delete_approval(
-        self,
-        run_id: RunId,
-        tool_call_id: str
-    ) -> ApprovalStorageResult:
+    async def delete_approval(self, run_id: RunId, tool_call_id: str) -> ApprovalStorageResult:
         """Delete approval for a tool call. Returns success status."""
         pass
 
@@ -119,16 +105,16 @@ class InMemoryApprovalStorage(ApprovalStorage):
         run_id: RunId,
         tool_call_id: str,
         approval: ApprovalValue,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> ApprovalStorageResult:
         """Store an approval decision."""
         try:
             async with self._lock:
                 run_key = self._get_run_key(run_id)
-                
+
                 if run_key not in self._approvals:
                     self._approvals[run_key] = {}
-                
+
                 # Enhance approval with metadata if provided
                 enhanced_approval = approval
                 if metadata:
@@ -136,27 +122,23 @@ class InMemoryApprovalStorage(ApprovalStorage):
                     enhanced_approval = ApprovalValue(
                         status=approval.status,
                         approved=approval.approved,
-                        additional_context=additional_context
+                        additional_context=additional_context,
                     )
-                
+
                 self._approvals[run_key][tool_call_id] = enhanced_approval
-                
+
             return ApprovalStorageResult.success_result()
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to store approval: {e}")
 
-    async def get_approval(
-        self,
-        run_id: RunId,
-        tool_call_id: str
-    ) -> ApprovalStorageResult:
+    async def get_approval(self, run_id: RunId, tool_call_id: str) -> ApprovalStorageResult:
         """Retrieve approval for a specific tool call."""
         try:
             async with self._lock:
                 run_key = self._get_run_key(run_id)
                 run_approvals = self._approvals.get(run_key, {})
                 approval = run_approvals.get(tool_call_id)
-                
+
             return ApprovalStorageResult.success_result(approval)
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to get approval: {e}")
@@ -167,63 +149,61 @@ class InMemoryApprovalStorage(ApprovalStorage):
             async with self._lock:
                 run_key = self._get_run_key(run_id)
                 run_approvals = self._approvals.get(run_key, {}).copy()
-                
+
             return ApprovalStorageResult.success_result(run_approvals)
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to get run approvals: {e}")
 
     async def update_approval(
-        self,
-        run_id: RunId,
-        tool_call_id: str,
-        updates: Dict[str, Any]
+        self, run_id: RunId, tool_call_id: str, updates: Dict[str, Any]
     ) -> ApprovalStorageResult:
         """Update existing approval."""
         try:
             async with self._lock:
                 run_key = self._get_run_key(run_id)
-                
+
                 if run_key not in self._approvals or tool_call_id not in self._approvals[run_key]:
                     return ApprovalStorageResult.error_result(
                         f"Approval not found for tool call {tool_call_id} in run {run_id}"
                     )
-                
+
                 existing = self._approvals[run_key][tool_call_id]
-                
+
                 # Merge additional context
-                merged_context = {**(existing.additional_context or {}), **(updates.get('additional_context', {}))}
-                
+                merged_context = {
+                    **(existing.additional_context or {}),
+                    **(updates.get("additional_context", {})),
+                }
+
                 updated_approval = ApprovalValue(
-                    status=updates.get('status', existing.status),
-                    approved=updates.get('approved', existing.approved),
-                    additional_context=merged_context if merged_context else existing.additional_context
+                    status=updates.get("status", existing.status),
+                    approved=updates.get("approved", existing.approved),
+                    additional_context=merged_context
+                    if merged_context
+                    else existing.additional_context,
                 )
-                
+
                 self._approvals[run_key][tool_call_id] = updated_approval
-                
+
             return ApprovalStorageResult.success_result()
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to update approval: {e}")
 
-    async def delete_approval(
-        self,
-        run_id: RunId,
-        tool_call_id: str
-    ) -> ApprovalStorageResult:
+    async def delete_approval(self, run_id: RunId, tool_call_id: str) -> ApprovalStorageResult:
         """Delete approval for a tool call."""
         try:
             async with self._lock:
                 run_key = self._get_run_key(run_id)
-                
+
                 if run_key not in self._approvals:
                     return ApprovalStorageResult.success_result(False)
-                
+
                 deleted = self._approvals[run_key].pop(tool_call_id, None) is not None
-                
+
                 # Clean up empty run maps
                 if not self._approvals[run_key]:
                     del self._approvals[run_key]
-                
+
             return ApprovalStorageResult.success_result(deleted)
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to delete approval: {e}")
@@ -233,13 +213,13 @@ class InMemoryApprovalStorage(ApprovalStorage):
         try:
             async with self._lock:
                 run_key = self._get_run_key(run_id)
-                
+
                 if run_key not in self._approvals:
                     return ApprovalStorageResult.success_result(0)
-                
+
                 count = len(self._approvals[run_key])
                 del self._approvals[run_key]
-                
+
             return ApprovalStorageResult.success_result(count)
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to clear run approvals: {e}")
@@ -252,7 +232,7 @@ class InMemoryApprovalStorage(ApprovalStorage):
                 approved_count = 0
                 rejected_count = 0
                 runs_with_approvals = len(self._approvals)
-                
+
                 for run_approvals in self._approvals.values():
                     for approval in run_approvals.values():
                         total_approvals += 1
@@ -260,14 +240,14 @@ class InMemoryApprovalStorage(ApprovalStorage):
                             approved_count += 1
                         else:
                             rejected_count += 1
-                
+
                 stats = {
-                    'total_approvals': total_approvals,
-                    'approved_count': approved_count,
-                    'rejected_count': rejected_count,
-                    'runs_with_approvals': runs_with_approvals
+                    "total_approvals": total_approvals,
+                    "approved_count": approved_count,
+                    "rejected_count": rejected_count,
+                    "runs_with_approvals": runs_with_approvals,
                 }
-                
+
             return ApprovalStorageResult.success_result(stats)
         except Exception as e:
             return ApprovalStorageResult.error_result(f"Failed to get stats: {e}")
@@ -277,18 +257,15 @@ class InMemoryApprovalStorage(ApprovalStorage):
         try:
             # Simple operation to test functionality
             await asyncio.sleep(0.001)  # Minimal async operation
-            
+
             health_data = {
-                'healthy': True,
-                'latency_ms': 1.0  # Approximate for in-memory
+                "healthy": True,
+                "latency_ms": 1.0,  # Approximate for in-memory
             }
-            
+
             return ApprovalStorageResult.success_result(health_data)
         except Exception as e:
-            health_data = {
-                'healthy': False,
-                'error': str(e)
-            }
+            health_data = {"healthy": False, "error": str(e)}
             return ApprovalStorageResult.success_result(health_data)
 
     async def close(self) -> ApprovalStorageResult:
@@ -303,4 +280,4 @@ class InMemoryApprovalStorage(ApprovalStorage):
 
 def create_in_memory_approval_storage() -> InMemoryApprovalStorage:
     """Create an in-memory approval storage instance."""
-    return InMemoryApprovalStorage()
+    return InMemoryApprovalStorage()

jaf/memory/factory.py

@@ -24,7 +24,7 @@ from .types import (
 
 
 async def create_memory_provider_from_env(
-    external_clients: Optional[Dict[str, Any]] = None
+    external_clients: Optional[Dict[str, Any]] = None,
 ) -> Result[MemoryProvider, MemoryConnectionError]:
     """
     Create a memory provider based on environment variables.
@@ -35,7 +35,7 @@ async def create_memory_provider_from_env(
     if memory_type == "memory":
         config = InMemoryConfig(
             max_conversations=int(os.getenv("JAF_MEMORY_MAX_CONVERSATIONS", "1000")),
-            max_messages_per_conversation=int(os.getenv("JAF_MEMORY_MAX_MESSAGES", "1000"))
+            max_messages_per_conversation=int(os.getenv("JAF_MEMORY_MAX_MESSAGES", "1000")),
         )
         return Success(create_in_memory_provider(config))
 
@@ -47,7 +47,7 @@ async def create_memory_provider_from_env(
             "port": int(os.getenv("JAF_REDIS_PORT", "6379")),
             "db": int(os.getenv("JAF_REDIS_DB", "0")),
             "key_prefix": os.getenv("JAF_REDIS_PREFIX", "jaf:memory:"),
-            "ttl": int(os.getenv("JAF_REDIS_TTL")) if os.getenv("JAF_REDIS_TTL") else None
+            "ttl": int(os.getenv("JAF_REDIS_TTL")) if os.getenv("JAF_REDIS_TTL") else None,
         }
         if redis_password:
             config_data["password"] = redis_password
@@ -65,7 +65,7 @@ async def create_memory_provider_from_env(
             "password": os.getenv("JAF_POSTGRES_PASSWORD"),
             "ssl": os.getenv("JAF_POSTGRES_SSL", "false").lower() == "true",
             "table_name": os.getenv("JAF_POSTGRES_TABLE", "conversations"),
-            "max_connections": int(os.getenv("JAF_POSTGRES_MAX_CONNECTIONS", "10"))
+            "max_connections": int(os.getenv("JAF_POSTGRES_MAX_CONNECTIONS", "10")),
         }
         if connection_string:
             config_data["connection_string"] = connection_string