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

jaf/a2a/agent_card.py

@@ -10,9 +10,7 @@ from .types import A2AAgent
 
 
 def generate_agent_card(
-    config: Dict[str, Any],
-    agents: Dict[str, A2AAgent],
-    base_url: str = "http://localhost:3000"
+    config: Dict[str, Any], agents: Dict[str, A2AAgent], base_url: str = "http://localhost:3000"
 ) -> Dict[str, Any]:
     """Pure function to generate Agent Card from A2A agents"""
     return {
@@ -26,13 +24,13 @@ def generate_agent_card(
         "capabilities": {
             "streaming": True,
             "pushNotifications": False,
-            "stateTransitionHistory": True
+            "stateTransitionHistory": True,
         },
         "defaultInputModes": ["text/plain", "application/json"],
         "defaultOutputModes": ["text/plain", "application/json"],
         "skills": generate_skills_from_agents(agents),
         "securitySchemes": generate_security_schemes(),
-        "security": generate_security_requirements()
+        "security": generate_security_requirements(),
     }
 
 
@@ -49,7 +47,7 @@ def generate_skills_from_agents(agents: Dict[str, A2AAgent]) -> List[Dict[str, A
             "tags": ["general"] + [tool.name for tool in agent.tools],
             "examples": generate_examples_for_agent(agent),
             "inputModes": agent.supported_content_types,
-            "outputModes": agent.supported_content_types
+            "outputModes": agent.supported_content_types,
         }
 
         # Create individual skills for each tool
@@ -61,7 +59,7 @@ def generate_skills_from_agents(agents: Dict[str, A2AAgent]) -> List[Dict[str, A
                 "tags": [tool.name, "tool", agent_name],
                 "examples": generate_examples_for_tool(tool),
                 "inputModes": ["text/plain", "application/json"],
-                "outputModes": ["text/plain", "application/json"]
+                "outputModes": ["text/plain", "application/json"],
             }
             for tool in agent.tools
         ]
@@ -80,10 +78,7 @@ def generate_skills_from_agents(agents: Dict[str, A2AAgent]) -> List[Dict[str, A
 
 def generate_examples_for_agent(agent: A2AAgent) -> List[str]:
     """Pure function to generate examples for an agent"""
-    base_examples = [
-        f"Ask {agent.name} for help",
-        f"What can {agent.name} do?"
-    ]
+    base_examples = [f"Ask {agent.name} for help", f"What can {agent.name} do?"]
 
     # Add tool-specific examples using functional approach
     tool_examples = [
@@ -96,11 +91,7 @@ def generate_examples_for_agent(agent: A2AAgent) -> List[str]:
 
 def generate_examples_for_tool(tool: Any) -> List[str]:
     """Pure function to generate examples for a tool"""
-    return [
-        f"Use {tool.name}",
-        tool.description,
-        f"Help me with {tool.name.replace('_', ' ')}"
-    ]
+    return [f"Use {tool.name}", tool.description, f"Help me with {tool.name.replace('_', ' ')}"]
 
 
 def generate_security_schemes() -> Dict[str, Any]:
@@ -109,14 +100,14 @@ def generate_security_schemes() -> Dict[str, Any]:
         "bearerAuth": {
             "type": "http",
             "scheme": "bearer",
-            "description": "Bearer token authentication"
+            "description": "Bearer token authentication",
         },
         "apiKey": {
             "type": "apiKey",
             "in": "header",
             "name": "X-API-Key",
-            "description": "API key authentication"
-        }
+            "description": "API key authentication",
+        },
     }
 
 
@@ -128,7 +119,7 @@ def generate_security_requirements() -> List[Dict[str, List[str]]]:
         # Optional bearer auth
         {"bearerAuth": []},
         # Optional API key
-        {"apiKey": []}
+        {"apiKey": []},
     ]
 
 
@@ -136,7 +127,7 @@ def generate_agent_card_for_agent(
     agent_name: str,
     agent: A2AAgent,
     config: Optional[Dict[str, Any]] = None,
-    base_url: str = "http://localhost:3000"
+    base_url: str = "http://localhost:3000",
 ) -> Dict[str, Any]:
     """Pure function to generate Agent Card for a specific agent"""
     agent_map = {agent_name: agent}
@@ -145,10 +136,10 @@ def generate_agent_card_for_agent(
         "name": (config or {}).get("name", agent.name),
         "description": (config or {}).get("description", agent.description),
         "version": (config or {}).get("version", "1.0.0"),
-        "provider": (config or {}).get("provider", {
-            "organization": "JAF Agent",
-            "url": "https://functional-agent-framework.com"
-        })
+        "provider": (config or {}).get(
+            "provider",
+            {"organization": "JAF Agent", "url": "https://functional-agent-framework.com"},
+        ),
     }
 
     return generate_agent_card(card_config, agent_map, base_url)
@@ -159,55 +150,66 @@ def validate_agent_card(card: Dict[str, Any]) -> Dict[str, Any]:
 
     # Validate required fields functionally
     required_field_errors = [
-        error for field, error_msg in [
+        error
+        for field, error_msg in [
             (card.get("name", "").strip(), "Agent card name is required"),
             (card.get("description", "").strip(), "Agent card description is required"),
             (card.get("url", "").strip(), "Agent card URL is required"),
             (card.get("version", "").strip(), "Agent card version is required"),
-            (card.get("protocolVersion", "").strip(), "Protocol version is required")
-        ] if not field
+            (card.get("protocolVersion", "").strip(), "Protocol version is required"),
+        ]
+        if not field
         for error in [error_msg]
     ]
 
     # Skills validation functionally
     skills = card.get("skills", [])
     skills_errors = (
-        ["At least one skill is required"] if not skills else
-        [
+        ["At least one skill is required"]
+        if not skills
+        else [
             error
             for index, skill in enumerate(skills)
             for error in [
                 f"Skill {index}: ID is required" if not skill.get("id", "").strip() else None,
                 f"Skill {index}: Name is required" if not skill.get("name", "").strip() else None,
-                f"Skill {index}: Description is required" if not skill.get("description", "").strip() else None,
-                f"Skill {index}: At least one tag is required" if not skill.get("tags") or len(skill.get("tags", [])) == 0 else None
-            ] if error is not None
+                f"Skill {index}: Description is required"
+                if not skill.get("description", "").strip()
+                else None,
+                f"Skill {index}: At least one tag is required"
+                if not skill.get("tags") or len(skill.get("tags", [])) == 0
+                else None,
+            ]
+            if error is not None
         ]
     )
 
     # Input/Output modes validation functionally
     mode_errors = [
-        error for condition, error in [
-            (not card.get("defaultInputModes") or len(card.get("defaultInputModes", [])) == 0, "At least one default input mode is required"),
-            (not card.get("defaultOutputModes") or len(card.get("defaultOutputModes", [])) == 0, "At least one default output mode is required")
-        ] if condition
+        error
+        for condition, error in [
+            (
+                not card.get("defaultInputModes") or len(card.get("defaultInputModes", [])) == 0,
+                "At least one default input mode is required",
+            ),
+            (
+                not card.get("defaultOutputModes") or len(card.get("defaultOutputModes", [])) == 0,
+                "At least one default output mode is required",
+            ),
+        ]
+        if condition
         for error in [error]
     ]
 
     # URL validation functionally
     url_errors = [
-        "Invalid URL format"
-        for url in [card.get("url")]
-        if url and not is_valid_url(url)
+        "Invalid URL format" for url in [card.get("url")] if url and not is_valid_url(url)
     ]
 
     # Combine all errors functionally
     errors = required_field_errors + skills_errors + mode_errors + url_errors
 
-    return {
-        "is_valid": len(errors) == 0,
-        "errors": errors
-    }
+    return {"is_valid": len(errors) == 0, "errors": errors}
 
 
 def is_valid_url(url: str) -> bool:
@@ -220,9 +222,7 @@ def is_valid_url(url: str) -> bool:
 
 
 def create_minimal_agent_card(
-    name: str,
-    description: str,
-    url: str = "http://localhost:3000/a2a"
+    name: str, description: str, url: str = "http://localhost:3000/a2a"
 ) -> Dict[str, Any]:
     """Pure function to create minimal Agent Card"""
     return {
@@ -235,17 +235,19 @@ def create_minimal_agent_card(
         "capabilities": {
             "streaming": True,
             "pushNotifications": False,
-            "stateTransitionHistory": False
+            "stateTransitionHistory": False,
         },
         "defaultInputModes": ["text/plain"],
         "defaultOutputModes": ["text/plain"],
-        "skills": [{
-            "id": "general",
-            "name": "General Assistant",
-            "description": "General purpose assistance",
-            "tags": ["general", "assistant"],
-            "examples": ["How can I help you?"]
-        }]
+        "skills": [
+            {
+                "id": "general",
+                "name": "General Assistant",
+                "description": "General purpose assistance",
+                "tags": ["general", "assistant"],
+                "examples": ["How can I help you?"],
+            }
+        ],
     }
 
 
@@ -258,11 +260,7 @@ def merge_agent_cards(*cards: Dict[str, Any]) -> Dict[str, Any]:
     additional_cards = cards[1:]
 
     # Merge skills functionally
-    all_skills = [
-        skill
-        for card in cards
-        for skill in card.get("skills", [])
-    ]
+    all_skills = [skill for card in cards for skill in card.get("skills", [])]
 
     # Remove duplicate skills by ID functionally
     seen_ids = set()
@@ -273,24 +271,35 @@ def merge_agent_cards(*cards: Dict[str, Any]) -> Dict[str, Any]:
     ]
 
     # Merge input/output modes
-    merged_input_modes = list(set([
-        *base_card.get("defaultInputModes", []),
-        *[mode for card in additional_cards for mode in card.get("defaultInputModes", [])]
-    ]))
+    merged_input_modes = list(
+        set(
+            [
+                *base_card.get("defaultInputModes", []),
+                *[mode for card in additional_cards for mode in card.get("defaultInputModes", [])],
+            ]
+        )
+    )
 
-    merged_output_modes = list(set([
-        *base_card.get("defaultOutputModes", []),
-        *[mode for card in additional_cards for mode in card.get("defaultOutputModes", [])]
-    ]))
+    merged_output_modes = list(
+        set(
+            [
+                *base_card.get("defaultOutputModes", []),
+                *[mode for card in additional_cards for mode in card.get("defaultOutputModes", [])],
+            ]
+        )
+    )
 
     # Merge capabilities
     capabilities = base_card.get("capabilities", {})
     for card in additional_cards:
         card_capabilities = card.get("capabilities", {})
         capabilities = {
-            "streaming": capabilities.get("streaming", False) or card_capabilities.get("streaming", False),
-            "pushNotifications": capabilities.get("pushNotifications", False) or card_capabilities.get("pushNotifications", False),
-            "stateTransitionHistory": capabilities.get("stateTransitionHistory", False) or card_capabilities.get("stateTransitionHistory", False)
+            "streaming": capabilities.get("streaming", False)
+            or card_capabilities.get("streaming", False),
+            "pushNotifications": capabilities.get("pushNotifications", False)
+            or card_capabilities.get("pushNotifications", False),
+            "stateTransitionHistory": capabilities.get("stateTransitionHistory", False)
+            or card_capabilities.get("stateTransitionHistory", False),
         }
 
     return {
@@ -298,7 +307,7 @@ def merge_agent_cards(*cards: Dict[str, Any]) -> Dict[str, Any]:
         "skills": unique_skills,
         "defaultInputModes": merged_input_modes,
         "defaultOutputModes": merged_output_modes,
-        "capabilities": capabilities
+        "capabilities": capabilities,
     }
 
 
@@ -313,17 +322,17 @@ def create_agent_card_from_config(config: Dict[str, Any]) -> Dict[str, Any]:
         "url": f"{base_url}/a2a",
         "preferredTransport": "JSONRPC",
         "version": config.get("version", "1.0.0"),
-        "provider": config.get("provider", {
-            "organization": "JAF Framework",
-            "url": "https://functional-agent-framework.com"
-        }),
+        "provider": config.get(
+            "provider",
+            {"organization": "JAF Framework", "url": "https://functional-agent-framework.com"},
+        ),
         "capabilities": {
             "streaming": True,
             "pushNotifications": False,
             "stateTransitionHistory": True,
-            **config.get("capabilities", {})
+            **config.get("capabilities", {}),
         },
         "defaultInputModes": ["text/plain", "application/json"],
         "defaultOutputModes": ["text/plain", "application/json"],
-        "skills": generate_skills_from_agents(config.get("agents", {}))
+        "skills": generate_skills_from_agents(config.get("agents", {})),
     }

jaf/a2a/client.py

@@ -24,16 +24,14 @@ def create_a2a_client(base_url: str, config: Optional[Dict[str, Any]] = None) ->
     return A2AClientState(
         config=A2AClientConfig(
             baseUrl=base_url.rstrip("/"),  # Remove trailing slash
-            timeout=config.get("timeout", 30000)
+            timeout=config.get("timeout", 30000),
         ),
-        sessionId=f"client_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}"
+        sessionId=f"client_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
     )
 
 
 def create_message_request(
-    message: str,
-    session_id: str,
-    configuration: Optional[Dict[str, Any]] = None
+    message: str, session_id: str, configuration: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """Pure function to create message request"""
     return {
@@ -46,17 +44,15 @@ def create_message_request(
                 "parts": [{"kind": "text", "text": message}],
                 "messageId": f"msg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
                 "contextId": session_id,
-                "kind": "message"
+                "kind": "message",
             },
-            "configuration": configuration
-        }
+            "configuration": configuration,
+        },
     }
 
 
 def create_streaming_message_request(
-    message: str,
-    session_id: str,
-    configuration: Optional[Dict[str, Any]] = None
+    message: str, session_id: str, configuration: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """Pure function to create streaming message request"""
     return {
@@ -69,18 +65,14 @@ def create_streaming_message_request(
                 "parts": [{"kind": "text", "text": message}],
                 "messageId": f"msg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
                 "contextId": session_id,
-                "kind": "message"
+                "kind": "message",
             },
-            "configuration": configuration
-        }
+            "configuration": configuration,
+        },
     }
 
 
-async def send_http_request(
-    url: str,
-    body: Dict[str, Any],
-    timeout: int = 30000
-) -> Dict[str, Any]:
+async def send_http_request(url: str, body: Dict[str, Any], timeout: int = 30000) -> Dict[str, Any]:
     """Pure function to send HTTP request"""
     timeout_seconds = timeout / 1000.0
 
@@ -89,10 +81,7 @@ async def send_http_request(
             response = await client.post(
                 url,
                 json=body,
-                headers={
-                    "Content-Type": "application/json",
-                    "Accept": "application/json"
-                }
+                headers={"Content-Type": "application/json", "Accept": "application/json"},
             )
 
             if not response.is_success:
@@ -104,19 +93,14 @@ async def send_http_request(
             raise Exception(f"Request timeout after {timeout}ms")
 
 
-async def send_a2a_request(
-    client: A2AClientState,
-    request: Dict[str, Any]
-) -> Dict[str, Any]:
+async def send_a2a_request(client: A2AClientState, request: Dict[str, Any]) -> Dict[str, Any]:
     """Pure function to send A2A request"""
     url = f"{client.config.base_url}/a2a"
     return await send_http_request(url, request, client.config.timeout)
 
 
 async def send_message(
-    client: A2AClientState,
-    message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    client: A2AClientState, message: str, configuration: Optional[Dict[str, Any]] = None
 ) -> str:
     """Pure function to send message"""
     request = create_message_request(message, client.session_id, configuration)
@@ -130,9 +114,7 @@ async def send_message(
 
 
 async def stream_message(
-    client: A2AClientState,
-    message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    client: A2AClientState, message: str, configuration: Optional[Dict[str, Any]] = None
 ) -> AsyncGenerator[Dict[str, Any], None]:
     """Pure function to stream message"""
     request = create_streaming_message_request(message, client.session_id, configuration)
@@ -146,12 +128,8 @@ async def stream_message(
                 "POST",
                 url,
                 json=request,
-                headers={
-                    "Content-Type": "application/json",
-                    "Accept": "text/event-stream"
-                }
+                headers={"Content-Type": "application/json", "Accept": "text/event-stream"},
             ) as response:
-
                 if not response.is_success:
                     raise Exception(f"HTTP {response.status_code}: {response.text}")
 
@@ -182,10 +160,7 @@ async def get_agent_card(client: A2AClientState) -> Dict[str, Any]:
     url = f"{client.config.base_url}/.well-known/agent-card"
 
     async with httpx.AsyncClient(timeout=client.config.timeout / 1000.0) as http_client:
-        response = await http_client.get(
-            url,
-            headers={"Accept": "application/json"}
-        )
+        response = await http_client.get(url, headers={"Accept": "application/json"})
 
         if not response.is_success:
             raise Exception(f"Failed to get agent card: HTTP {response.status_code}")
@@ -203,7 +178,7 @@ async def send_message_to_agent(
     client: A2AClientState,
     agent_name: str,
     message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    configuration: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Pure function to send message to specific agent"""
     request = create_message_request(message, client.session_id, configuration)
@@ -222,7 +197,7 @@ async def stream_message_to_agent(
     client: A2AClientState,
     agent_name: str,
     message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    configuration: Optional[Dict[str, Any]] = None,
 ) -> AsyncGenerator[Dict[str, Any], None]:
     """Pure function to stream message to specific agent"""
     request = create_streaming_message_request(message, client.session_id, configuration)
@@ -236,12 +211,8 @@ async def stream_message_to_agent(
                 "POST",
                 url,
                 json=request,
-                headers={
-                    "Content-Type": "application/json",
-                    "Accept": "text/event-stream"
-                }
+                headers={"Content-Type": "application/json", "Accept": "text/event-stream"},
             ) as response:
-
                 if not response.is_success:
                     raise Exception(f"HTTP {response.status_code}: {response.text}")
 
@@ -320,10 +291,7 @@ async def check_a2a_health(client: A2AClientState) -> Dict[str, Any]:
     url = f"{client.config.base_url}/a2a/health"
 
     async with httpx.AsyncClient(timeout=client.config.timeout / 1000.0) as http_client:
-        response = await http_client.get(
-            url,
-            headers={"Accept": "application/json"}
-        )
+        response = await http_client.get(url, headers={"Accept": "application/json"})
 
         if not response.is_success:
             raise Exception(f"Health check failed: HTTP {response.status_code}")
@@ -336,10 +304,7 @@ async def get_a2a_capabilities(client: A2AClientState) -> Dict[str, Any]:
     url = f"{client.config.base_url}/a2a/capabilities"
 
     async with httpx.AsyncClient(timeout=client.config.timeout / 1000.0) as http_client:
-        response = await http_client.get(
-            url,
-            headers={"Accept": "application/json"}
-        )
+        response = await http_client.get(url, headers={"Accept": "application/json"})
 
         if not response.is_success:
             raise Exception(f"Capabilities request failed: HTTP {response.status_code}")
@@ -371,16 +336,15 @@ async def connect_to_a2a_agent(base_url: str) -> Dict[str, Any]:
         "ask": ask,
         "stream": stream,
         "health": health,
-        "capabilities": capabilities
+        "capabilities": capabilities,
     }
 
 
 # Utility functions
 
+
 def create_a2a_message_dict(
-    text: str,
-    role: str = "user",
-    context_id: Optional[str] = None
+    text: str, role: str = "user", context_id: Optional[str] = None
 ) -> Dict[str, Any]:
     """Utility function to create A2A message dictionary"""
     return {
@@ -388,7 +352,7 @@ def create_a2a_message_dict(
         "parts": [{"kind": "text", "text": text}],
         "messageId": f"msg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
         "contextId": context_id,
-        "kind": "message"
+        "kind": "message",
     }
 
 
@@ -410,8 +374,8 @@ def parse_sse_event(line: str) -> Optional[Dict[str, Any]]:
 def validate_a2a_response(response: Dict[str, Any]) -> bool:
     """Pure function to validate A2A response"""
     return (
-        isinstance(response, dict) and
-        response.get("jsonrpc") == "2.0" and
-        "id" in response and
-        ("result" in response or "error" in response)
+        isinstance(response, dict)
+        and response.get("jsonrpc") == "2.0"
+        and "id" in response
+        and ("result" in response or "error" in response)
     )

jaf/a2a/examples/client_example.py

@@ -7,13 +7,13 @@ using the JAF A2A client library.
 Usage:
     # Start the server first:
     python server_example.py
-    
+
     # Then run this client:
     python client_example.py
 
 The client will connect to http://localhost:3000 and demonstrate:
 - Agent discovery via Agent Cards
-- Sending messages to specific agents  
+- Sending messages to specific agents
 - Streaming message responses
 - Health checks and capabilities
 - Error handling
@@ -46,11 +46,11 @@ async def discover_server_agents(base_url: str):
         print(f"🌐 URL: {agent_card['url']}")
         print(f"📡 Protocol: {agent_card['protocolVersion']}")
 
-        skills = agent_card.get('skills', [])
+        skills = agent_card.get("skills", [])
         print(f"\n🛠️ Available skills ({len(skills)}):")
         for skill in skills:
             print(f"   • {skill['name']}: {skill['description']}")
-            if skill.get('tags'):
+            if skill.get("tags"):
                 print(f"     Tags: {', '.join(skill['tags'])}")
 
         return agent_card
@@ -70,18 +70,18 @@ async def check_server_health(client):
         print(f"📡 Protocol: {health.get('protocol', 'unknown')}")
         print(f"🔢 Version: {health.get('version', 'unknown')}")
 
-        agents = health.get('agents', [])
+        agents = health.get("agents", [])
         if agents:
             print(f"🤖 Available agents: {', '.join(agents)}")
 
         print("\n⚡ Getting capabilities...")
         capabilities = await get_a2a_capabilities(client)
 
-        methods = capabilities.get('supportedMethods', [])
+        methods = capabilities.get("supportedMethods", [])
         if methods:
             print(f"📋 Supported methods: {', '.join(methods)}")
 
-        transports = capabilities.get('supportedTransports', [])
+        transports = capabilities.get("supportedTransports", [])
         if transports:
             print(f"🚀 Supported transports: {', '.join(transports)}")
 
@@ -100,7 +100,7 @@ async def test_math_agent(client):
         "What is 25 + 17?",
         "Calculate 144 / 12",
         "What is 2^8?",
-        "Can you solve (15 + 5) * 3?"
+        "Can you solve (15 + 5) * 3?",
     ]
 
     for question in test_cases:
@@ -121,7 +121,7 @@ async def test_weather_agent(client):
         "What's the weather in London?",
         "How's the weather in Tokyo?",
         "Tell me about the weather in New York",
-        "Weather forecast for Sydney please"
+        "Weather forecast for Sydney please",
     ]
 
     for question in locations:
@@ -142,7 +142,7 @@ async def test_translator_agent(client):
         "Translate 'Hello, how are you?' to Spanish",
         "Can you translate 'Good morning' to French?",
         "Translate 'Thank you very much' to German",
-        "Convert 'Beautiful day' to Italian"
+        "Convert 'Beautiful day' to Italian",
     ]
 
     for question in translations:
@@ -179,7 +179,7 @@ async def test_general_assistant(client):
         "Hello, what can you help me with?",
         "Tell me a joke",
         "What is the meaning of life?",
-        "How can I be more productive?"
+        "How can I be more productive?",
     ]
 
     for question in questions:
@@ -212,7 +212,7 @@ async def test_convenience_connection():
 
         # Test capabilities
         capabilities = await connection["capabilities"]()
-        methods = capabilities.get('supportedMethods', [])
+        methods = capabilities.get("supportedMethods", [])
         print(f"⚡ Methods via convenience: {len(methods)} methods")
 
         return True