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

jaf/a2a/examples/integration_example.py

@@ -36,7 +36,7 @@ class MockModelProvider:
         return {
             "message": {
                 "content": f"[{agent.name}] I received: '{last_message}'",
-                "tool_calls": None
+                "tool_calls": None,
             }
         }
 
@@ -55,7 +55,7 @@ async def echo_tool(args: EchoArgs, context) -> Dict[str, Any]:
     return {
         "result": f"Echo: {args.message}",
         "original": args.message,
-        "length": len(args.message)
+        "length": len(args.message),
     }
 
 
@@ -66,11 +66,7 @@ async def count_tool(args: CountArgs, context) -> Dict[str, Any]:
 
     return {
         "result": f"Text analysis: {char_count} characters, {word_count} words",
-        "analysis": {
-            "characters": char_count,
-            "words": word_count,
-            "text": args.text
-        }
+        "analysis": {"characters": char_count, "words": word_count, "text": args.text},
     }
 
 
@@ -79,17 +75,14 @@ def create_test_agents():
 
     # Echo Agent
     echo_tool_obj = create_a2a_tool(
-        "echo",
-        "Echo back a message",
-        EchoArgs.model_json_schema(),
-        echo_tool
+        "echo", "Echo back a message", EchoArgs.model_json_schema(), echo_tool
     )
 
     echo_agent = create_a2a_agent(
         "EchoBot",
         "An agent that echoes messages back",
         "You are an echo bot. Use the echo tool to repeat messages.",
-        [echo_tool_obj]
+        [echo_tool_obj],
     )
 
     # Counter Agent
@@ -97,14 +90,14 @@ def create_test_agents():
         "count_chars",
         "Count characters and words in text",
         CountArgs.model_json_schema(),
-        count_tool
+        count_tool,
     )
 
     counter_agent = create_a2a_agent(
         "CounterBot",
         "An agent that counts characters and words",
         "You are a text analysis bot. Use the counting tool to analyze text.",
-        [count_tool_obj]
+        [count_tool_obj],
     )
 
     # Simple Chat Agent (no tools)
@@ -112,14 +105,10 @@ def create_test_agents():
         "ChatBot",
         "A simple conversational agent",
         "You are a friendly chat bot. Be helpful and conversational.",
-        []
+        [],
     )
 
-    return {
-        "EchoBot": echo_agent,
-        "CounterBot": counter_agent,
-        "ChatBot": chat_agent
-    }
+    return {"EchoBot": echo_agent, "CounterBot": counter_agent, "ChatBot": chat_agent}
 
 
 async def start_test_server():
@@ -134,7 +123,7 @@ async def start_test_server():
         name="Test A2A Server",
         description="Integration test server with sample agents",
         host="localhost",
-        port=3001  # Use different port to avoid conflicts
+        port=3001,  # Use different port to avoid conflicts
     )
 
     server_config["model_provider"] = MockModelProvider()
@@ -163,18 +152,18 @@ async def test_client_interactions(base_url: str):
         {
             "agent": "EchoBot",
             "message": "Hello, echo bot!",
-            "description": "Testing echo functionality"
+            "description": "Testing echo functionality",
         },
         {
             "agent": "CounterBot",
             "message": "Count the characters in this sentence please",
-            "description": "Testing character counting"
+            "description": "Testing character counting",
         },
         {
             "agent": "ChatBot",
             "message": "Hi there, how are you doing today?",
-            "description": "Testing general conversation"
-        }
+            "description": "Testing general conversation",
+        },
     ]
 
     results = []
@@ -185,29 +174,29 @@ async def test_client_interactions(base_url: str):
         print(f"   Message: {test_case['message']}")
 
         try:
-            response = await send_message_to_agent(
-                client,
-                test_case['agent'],
-                test_case['message']
-            )
+            response = await send_message_to_agent(client, test_case["agent"], test_case["message"])
 
             print(f"✅ Response: {response}")
 
-            results.append({
-                "agent": test_case['agent'],
-                "message": test_case['message'],
-                "response": response,
-                "success": True
-            })
+            results.append(
+                {
+                    "agent": test_case["agent"],
+                    "message": test_case["message"],
+                    "response": response,
+                    "success": True,
+                }
+            )
 
         except Exception as error:
             print(f"❌ Error: {error}")
-            results.append({
-                "agent": test_case['agent'],
-                "message": test_case['message'],
-                "error": str(error),
-                "success": False
-            })
+            results.append(
+                {
+                    "agent": test_case["agent"],
+                    "message": test_case["message"],
+                    "error": str(error),
+                    "success": False,
+                }
+            )
 
     return results
 
@@ -224,7 +213,7 @@ async def test_agent_discovery(base_url: str):
         print(f"✅ Discovered server: {agent_card['name']}")
         print(f"📄 Description: {agent_card['description']}")
 
-        skills = agent_card.get('skills', [])
+        skills = agent_card.get("skills", [])
         print(f"🛠️ Skills found: {len(skills)}")
 
         for skill in skills:
@@ -252,7 +241,7 @@ async def test_health_and_capabilities(base_url: str):
 
         # Capabilities
         capabilities = await get_a2a_capabilities(client)
-        methods = capabilities.get('supportedMethods', [])
+        methods = capabilities.get("supportedMethods", [])
         print(f"⚡ Supported methods: {', '.join(methods)}")
 
         return True
@@ -294,7 +283,7 @@ async def main():
         print("\n📊 Integration Test Summary")
         print("=" * 30)
 
-        successful = sum(1 for r in results if r['success'])
+        successful = sum(1 for r in results if r["success"])
         total = len(results)
 
         print(f"✅ Successful interactions: {successful}/{total}")
@@ -305,8 +294,10 @@ async def main():
             print("⚠️ Some tests failed. Check the errors above.")
 
         for result in results:
-            status = "✅" if result['success'] else "❌"
-            print(f"   {status} {result['agent']}: {result.get('response', result.get('error', 'Unknown'))[:60]}...")
+            status = "✅" if result["success"] else "❌"
+            print(
+                f"   {status} {result['agent']}: {result.get('response', result.get('error', 'Unknown'))[:60]}..."
+            )
 
         print("\n🔧 Integration Features Tested:")
         print("   • Agent discovery via Agent Cards")

jaf/a2a/examples/server_example.py

@@ -9,7 +9,7 @@ Usage:
 
 The server will start on http://localhost:3000 with the following endpoints:
 - /.well-known/agent-card - Agent discovery
-- /a2a - Main A2A JSON-RPC endpoint  
+- /a2a - Main A2A JSON-RPC endpoint
 - /a2a/agents/{name} - Agent-specific endpoints
 - /a2a/health - Health check
 - /a2a/capabilities - Server capabilities
@@ -39,21 +39,21 @@ class MockModelProvider:
             return {
                 "message": {
                     "content": f"I can help with math! I see you said: '{last_message}'",
-                    "tool_calls": None
+                    "tool_calls": None,
                 }
             }
         elif "weather" in agent_name:
             return {
                 "message": {
                     "content": f"I can check weather! You asked: '{last_message}'",
-                    "tool_calls": None
+                    "tool_calls": None,
                 }
             }
         else:
             return {
                 "message": {
                     "content": f"Hello! I'm {agent.name}. You said: '{last_message}'",
-                    "tool_calls": None
+                    "tool_calls": None,
                 }
             }
 
@@ -61,17 +61,20 @@ class MockModelProvider:
 # Tool argument models
 class CalculateArgs(BaseModel):
     """Arguments for calculator tool"""
+
     expression: str = Field(description="Mathematical expression to evaluate")
 
 
 class WeatherArgs(BaseModel):
     """Arguments for weather tool"""
+
     location: str = Field(description="City or location name")
     units: str = Field(default="celsius", description="Temperature units (celsius/fahrenheit)")
 
 
 class TranslateArgs(BaseModel):
     """Arguments for translation tool"""
+
     text: str = Field(description="Text to translate")
     target_language: str = Field(description="Target language code (e.g., 'es', 'fr', 'de')")
 
@@ -95,10 +98,10 @@ async def calculator_tool(args: CalculateArgs, context) -> Dict[str, Any]:
     }
 
     allowed_functions = {
-        'abs': abs,
-        'round': round,
-        'min': min,
-        'max': max,
+        "abs": abs,
+        "round": round,
+        "min": min,
+        "max": max,
     }
 
     def safe_eval_node(node):
@@ -107,8 +110,9 @@ async def calculator_tool(args: CalculateArgs, context) -> Dict[str, Any]:
             return node.value
         elif isinstance(node, ast.Name):
             # Only allow specific constants
-            if node.id in ['pi', 'e']:
+            if node.id in ["pi", "e"]:
                 import math
+
                 return getattr(math, node.id)
             else:
                 raise ValueError(f"Name '{node.id}' is not allowed")
@@ -139,9 +143,24 @@ async def calculator_tool(args: CalculateArgs, context) -> Dict[str, Any]:
 
         # Additional security checks
         dangerous_patterns = [
-            'import', 'exec', 'eval', '__', 'open', 'file', 'input',
-            'raw_input', 'compile', 'globals', 'locals', 'vars', 'dir',
-            'getattr', 'setattr', 'hasattr', 'delattr', 'callable'
+            "import",
+            "exec",
+            "eval",
+            "__",
+            "open",
+            "file",
+            "input",
+            "raw_input",
+            "compile",
+            "globals",
+            "locals",
+            "vars",
+            "dir",
+            "getattr",
+            "setattr",
+            "hasattr",
+            "delattr",
+            "callable",
         ]
 
         expression_lower = expression.lower()
@@ -149,51 +168,33 @@ async def calculator_tool(args: CalculateArgs, context) -> Dict[str, Any]:
             if pattern in expression_lower:
                 return {
                     "error": f"Security violation: '{pattern}' is not allowed in expressions",
-                    "result": None
+                    "result": None,
                 }
 
         # Parse expression into AST
         try:
-            parsed = ast.parse(expression, mode='eval')
+            parsed = ast.parse(expression, mode="eval")
         except SyntaxError as e:
-            return {
-                "error": f"Invalid mathematical expression: {e!s}",
-                "result": None
-            }
+            return {"error": f"Invalid mathematical expression: {e!s}", "result": None}
 
         # Evaluate safely
         result = safe_eval_node(parsed.body)
 
         # Handle division by zero and other math errors
         if not isinstance(result, (int, float, complex)):
-            return {
-                "error": "Expression must evaluate to a number",
-                "result": None
-            }
+            return {"error": "Expression must evaluate to a number", "result": None}
 
         return {
             "result": f"The result of {expression} is {result}",
-            "calculation": {
-                "expression": expression,
-                "result": result
-            }
+            "calculation": {"expression": expression, "result": result},
         }
 
     except ZeroDivisionError:
-        return {
-            "error": "Division by zero is not allowed",
-            "result": None
-        }
+        return {"error": "Division by zero is not allowed", "result": None}
     except ValueError as e:
-        return {
-            "error": f"Invalid expression: {e!s}",
-            "result": None
-        }
+        return {"error": f"Invalid expression: {e!s}", "result": None}
     except Exception as e:
-        return {
-            "error": f"Calculation error: {e!s}",
-            "result": None
-        }
+        return {"error": f"Calculation error: {e!s}", "result": None}
 
 
 async def weather_tool(args: WeatherArgs, context) -> Dict[str, Any]:
@@ -205,14 +206,14 @@ async def weather_tool(args: WeatherArgs, context) -> Dict[str, Any]:
         "units": args.units,
         "condition": "Partly cloudy",
         "humidity": 65,
-        "wind_speed": 15
+        "wind_speed": 15,
     }
 
     temp_unit = "°C" if args.units == "celsius" else "°F"
 
     return {
         "result": f"Weather in {args.location}: {weather_data['temperature']}{temp_unit}, {weather_data['condition']}",
-        "weather_data": weather_data
+        "weather_data": weather_data,
     }
 
 
@@ -224,18 +225,20 @@ async def translate_tool(args: TranslateArgs, context) -> Dict[str, Any]:
         "fr": f"[French] {args.text}",
         "de": f"[German] {args.text}",
         "it": f"[Italian] {args.text}",
-        "pt": f"[Portuguese] {args.text}"
+        "pt": f"[Portuguese] {args.text}",
     }
 
-    translated = translations.get(args.target_language, f"[{args.target_language.upper()}] {args.text}")
+    translated = translations.get(
+        args.target_language, f"[{args.target_language.upper()}] {args.text}"
+    )
 
     return {
         "result": f"Translation to {args.target_language}: {translated}",
         "translation": {
             "original": args.text,
             "translated": translated,
-            "target_language": args.target_language
-        }
+            "target_language": args.target_language,
+        },
     }
 
 
@@ -247,14 +250,14 @@ def create_example_agents():
         "calculator",
         "Perform mathematical calculations",
         CalculateArgs.model_json_schema(),
-        calculator_tool
+        calculator_tool,
     )
 
     math_agent = create_a2a_agent(
         "MathTutor",
         "A mathematical assistant that can solve equations and calculations",
         "You are a helpful math tutor. Use the calculator tool for computations.",
-        [calc_tool]
+        [calc_tool],
     )
 
     # Weather Agent with weather tool
@@ -262,14 +265,14 @@ def create_example_agents():
         "get_weather",
         "Get current weather information for a location",
         WeatherArgs.model_json_schema(),
-        weather_tool
+        weather_tool,
     )
 
     weather_agent = create_a2a_agent(
         "WeatherBot",
         "A weather assistant that provides current weather information",
         "You are a weather assistant. Use the weather tool to get current conditions.",
-        [weather_tool_obj]
+        [weather_tool_obj],
     )
 
     # Translation Agent with translation tool
@@ -277,14 +280,14 @@ def create_example_agents():
         "translate_text",
         "Translate text between languages",
         TranslateArgs.model_json_schema(),
-        translate_tool
+        translate_tool,
     )
 
     translation_agent = create_a2a_agent(
         "Translator",
         "A multilingual assistant that can translate text between languages",
         "You are a translation assistant. Use the translation tool for language conversion.",
-        [translate_tool_obj]
+        [translate_tool_obj],
     )
 
     # General Assistant (no specific tools)
@@ -292,14 +295,14 @@ def create_example_agents():
         "Assistant",
         "A general-purpose helpful assistant",
         "You are a helpful, friendly assistant ready to help with various tasks.",
-        []
+        [],
     )
 
     return {
         "MathTutor": math_agent,
         "WeatherBot": weather_agent,
         "Translator": translation_agent,
-        "Assistant": general_agent
+        "Assistant": general_agent,
     }
 
 
@@ -321,7 +324,7 @@ async def main():
             name="JAF A2A Example Server",
             description="Multi-agent server showcasing A2A protocol capabilities",
             host="localhost",
-            port=3000
+            port=3000,
         )
 
         # Add mock model provider

jaf/a2a/memory/__init__.py

@@ -78,7 +78,6 @@ __all__ = [
     "A2ATaskSerialized",
     "A2ATaskCleanupConfig",
     "CleanupResult",
-
     # Factory functions
     "create_a2a_task_error",
     "create_a2a_task_not_found_error",
@@ -89,7 +88,6 @@ __all__ = [
     "create_a2a_task_provider_from_env",
     "create_simple_a2a_task_provider",
     "create_composite_a2a_task_provider",
-
     # Serialization functions
     "serialize_a2a_task",
     "deserialize_a2a_task",
@@ -98,14 +96,12 @@ __all__ = [
     "validate_task_integrity",
     "clone_task",
     "sanitize_task",
-
     # Cleanup functions
     "default_cleanup_config",
     "perform_task_cleanup",
     "create_task_cleanup_scheduler",
     "validate_cleanup_config",
     "create_cleanup_config_from_env",
-
     # Validation functions
     "validate_a2a_task_provider_config",
     "is_a2a_task_error",

jaf/a2a/memory/cleanup.py

@@ -106,9 +106,7 @@ async def perform_task_cleanup(
         )
 
     if not config.enabled:
-        return create_a2a_success(
-            CleanupResult(0, 0, 0, 0, [], 0)
-        )
+        return create_a2a_success(CleanupResult(0, 0, 0, 0, [], 0))
 
     errors: List[str] = []
     tasks_to_delete: Set[str] = set()
@@ -116,7 +114,7 @@ async def perform_task_cleanup(
     # 1. Age-based cleanup
     if config.max_age is not None:
         cutoff_date = datetime.now(timezone.utc) - timedelta(seconds=config.max_age)
-        
+
         # Find all tasks older than the cutoff date
         # We query all states and filter out the ones to retain
         try:
@@ -124,7 +122,7 @@ async def perform_task_cleanup(
                 A2ATaskQuery(
                     context_id=context_id,
                     until=cutoff_date,
-                    limit=10000 # A high limit to get a large batch
+                    limit=10000,  # A high limit to get a large batch
                 )
             )
 
@@ -145,18 +143,27 @@ async def perform_task_cleanup(
     if config.max_completed_tasks is not None:
         try:
             completed_tasks_result = await task_provider.find_tasks(
-                A2ATaskQuery(state=TaskState.COMPLETED, context_id=context_id, limit=config.max_completed_tasks + 200)
+                A2ATaskQuery(
+                    state=TaskState.COMPLETED,
+                    context_id=context_id,
+                    limit=config.max_completed_tasks + 200,
+                )
             )
             if completed_tasks_result.data:
                 tasks = [t for t in completed_tasks_result.data if t.id not in tasks_to_delete]
                 if len(tasks) > config.max_completed_tasks:
-                    tasks.sort(key=lambda t: t.status.timestamp or datetime.min.replace(tzinfo=timezone.utc))
+                    tasks.sort(
+                        key=lambda t: t.status.timestamp
+                        or datetime.min.replace(tzinfo=timezone.utc)
+                    )
                     num_to_delete = len(tasks) - config.max_completed_tasks
                     for i in range(num_to_delete):
                         tasks_to_delete.add(tasks[i].id)
                         excess_completed_cleaned += 1
             elif completed_tasks_result.error:
-                errors.append(f"Failed to query completed tasks: {completed_tasks_result.error.message}")
+                errors.append(
+                    f"Failed to query completed tasks: {completed_tasks_result.error.message}"
+                )
         except Exception as e:
             errors.append(f"Error during completed task count cleanup: {e!s}")
 
@@ -165,12 +172,19 @@ async def perform_task_cleanup(
     if config.max_failed_tasks is not None:
         try:
             failed_tasks_result = await task_provider.find_tasks(
-                A2ATaskQuery(state=TaskState.FAILED, context_id=context_id, limit=config.max_failed_tasks + 200)
+                A2ATaskQuery(
+                    state=TaskState.FAILED,
+                    context_id=context_id,
+                    limit=config.max_failed_tasks + 200,
+                )
             )
             if failed_tasks_result.data:
                 tasks = [t for t in failed_tasks_result.data if t.id not in tasks_to_delete]
                 if len(tasks) > config.max_failed_tasks:
-                    tasks.sort(key=lambda t: t.status.timestamp or datetime.min.replace(tzinfo=timezone.utc))
+                    tasks.sort(
+                        key=lambda t: t.status.timestamp
+                        or datetime.min.replace(tzinfo=timezone.utc)
+                    )
                     num_to_delete = len(tasks) - config.max_failed_tasks
                     for i in range(num_to_delete):
                         tasks_to_delete.add(tasks[i].id)
@@ -180,7 +194,6 @@ async def perform_task_cleanup(
         except Exception as e:
             errors.append(f"Error during failed task count cleanup: {e!s}")
 
-
     if config.dry_run:
         return create_a2a_success(
             CleanupResult(
@@ -210,7 +223,7 @@ async def perform_task_cleanup(
     # This is complex as we don't know which category succeeded.
     # The initial counts are based on intent.
     # For now, we return the intended breakdown and total actual deletions.
-    
+
     final_result = CleanupResult(
         expired_cleaned=expired_cleaned,
         excess_completed_cleaned=excess_completed_cleaned,
@@ -294,9 +307,7 @@ class TaskCleanupScheduler:
                         f"A2A task cleanup completed: {cleanup_result.total_cleaned} tasks cleaned"
                     )
                     if cleanup_result.errors:
-                        print(
-                            f"A2A task cleanup errors: {', '.join(cleanup_result.errors)}"
-                        )
+                        print(f"A2A task cleanup errors: {', '.join(cleanup_result.errors)}")
             elif result.error:
                 print(f"A2A task cleanup failed: {result.error.message}")
 
@@ -318,18 +329,14 @@ def create_cleanup_config_from_env() -> A2ATaskCleanupConfig:
     """
     Helper function to create cleanup config from environment variables
     """
-    retain_states_str = os.getenv(
-        "JAF_A2A_CLEANUP_RETAIN_STATES", "working,submitted"
-    )
+    retain_states_str = os.getenv("JAF_A2A_CLEANUP_RETAIN_STATES", "working,submitted")
     retain_states = [s.strip() for s in retain_states_str.split(",") if s.strip()]
 
     return A2ATaskCleanupConfig(
         enabled=os.getenv("JAF_A2A_CLEANUP_ENABLED", "true").lower() == "true",
         interval=int(os.getenv("JAF_A2A_CLEANUP_INTERVAL", "3600")),
         max_age=int(os.getenv("JAF_A2A_CLEANUP_MAX_AGE", str(7 * 24 * 60 * 60))),
-        max_completed_tasks=int(
-            os.getenv("JAF_A2A_CLEANUP_MAX_COMPLETED", "1000")
-        ),
+        max_completed_tasks=int(os.getenv("JAF_A2A_CLEANUP_MAX_COMPLETED", "1000")),
         max_failed_tasks=int(os.getenv("JAF_A2A_CLEANUP_MAX_FAILED", "500")),
         retain_states=retain_states,
         batch_size=int(os.getenv("JAF_A2A_CLEANUP_BATCH_SIZE", "100")),