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

jaf/core/handoff.py

@@ -17,30 +17,36 @@ except ImportError:
     BaseModel = None
     Field = None
 
-Ctx = TypeVar('Ctx')
+Ctx = TypeVar("Ctx")
 
 
 def _create_handoff_json(agent_name: str, message: str = "") -> str:
     """Create the JSON structure for handoff requests."""
-    return json.dumps({
-        "handoff_to": agent_name,
-        "message": message or f"Handing off to {agent_name}",
-        "type": "handoff"
-    })
+    return json.dumps(
+        {
+            "handoff_to": agent_name,
+            "message": message or f"Handing off to {agent_name}",
+            "type": "handoff",
+        }
+    )
 
 
 if BaseModel is not None and Field is not None:
+
     class _HandoffInput(BaseModel):
         """Input parameters for handoff tool (Pydantic model)."""
+
         agent_name: str = Field(description="Name of the agent to hand off to")
         message: str = Field(description="Message or context to pass to the target agent")
 else:
+
     class _HandoffInput(object):
         """Plain-Python fallback for handoff input when Pydantic is unavailable.
 
         This class intentionally does not call Field() so it is safe to import
         when Pydantic is not installed.
         """
+
         agent_name: str
         message: str
 
@@ -48,12 +54,14 @@ else:
             self.agent_name = agent_name
             self.message = message
 
+
 HandoffInput = _HandoffInput
 
 
 @dataclass
 class HandoffResult:
     """Result of a handoff operation."""
+
     target_agent: str
     message: str
     success: bool = True
@@ -74,20 +82,20 @@ class HandoffTool:
                 "properties": {
                     "agent_name": {
                         "type": "string",
-                        "description": "Name of the agent to hand off to"
+                        "description": "Name of the agent to hand off to",
                     },
                     "message": {
                         "type": "string",
-                        "description": "Message or context to pass to the target agent"
-                    }
+                        "description": "Message or context to pass to the target agent",
+                    },
                 },
-                "required": ["agent_name", "message"]
+                "required": ["agent_name", "message"],
             }
 
         self.schema = ToolSchema(
             name="handoff",
             description="Hand off the conversation to another agent",
-            parameters=parameters_model
+            parameters=parameters_model,
         )
         self.source = ToolSource.NATIVE
         self.metadata = {"type": "handoff", "system": True}
@@ -101,35 +109,41 @@ class HandoffTool:
             context (Any): Context containing current agent and run state information.
         """
         # Extract arguments
-        if hasattr(args, 'agent_name'):
+        if hasattr(args, "agent_name"):
             agent_name = args.agent_name
             message = args.message
         elif isinstance(args, dict):
-            agent_name = args.get('agent_name', '')
-            message = args.get('message', '')
+            agent_name = args.get("agent_name", "")
+            message = args.get("message", "")
         else:
-            return json.dumps({
-                "error": "invalid_handoff_args",
-                "message": "Invalid handoff arguments provided",
-                "usage": "handoff(agent_name='target_agent', message='optional context')"
-            })
+            return json.dumps(
+                {
+                    "error": "invalid_handoff_args",
+                    "message": "Invalid handoff arguments provided",
+                    "usage": "handoff(agent_name='target_agent', message='optional context')",
+                }
+            )
 
         if not agent_name:
-            return json.dumps({
-                "error": "missing_agent_name",
-                "message": "Agent name is required for handoff",
-                "usage": "handoff(agent_name='target_agent', message='optional context')"
-            })
+            return json.dumps(
+                {
+                    "error": "missing_agent_name",
+                    "message": "Agent name is required for handoff",
+                    "usage": "handoff(agent_name='target_agent', message='optional context')",
+                }
+            )
 
         # Add agent validation if we have access to current agent info
-        if context and hasattr(context, 'current_agent'):
+        if context and hasattr(context, "current_agent"):
             current_agent = context.current_agent
             if current_agent.handoffs and agent_name not in current_agent.handoffs:
-                return json.dumps({
-                    "error": "handoff_not_allowed",
-                    "message": f"Agent {current_agent.name} cannot handoff to {agent_name}",
-                    "allowed_handoffs": current_agent.handoffs
-                })
+                return json.dumps(
+                    {
+                        "error": "handoff_not_allowed",
+                        "message": f"Agent {current_agent.name} cannot handoff to {agent_name}",
+                        "allowed_handoffs": current_agent.handoffs,
+                    }
+                )
 
         # Return the special handoff JSON that the engine recognizes
         return _create_handoff_json(agent_name, message)
@@ -139,8 +153,10 @@ def create_handoff_tool() -> Tool:
     """Create a handoff tool that can be added to any agent."""
     return HandoffTool()
 
+
 handoff_tool = create_handoff_tool()
 
+
 def handoff(agent_name: str, message: str = "") -> str:
     """
     Simple function to perform a handoff (for use in agent tools).
@@ -188,4 +204,4 @@ def extract_handoff_target(result: str) -> Optional[str]:
             return parsed["handoff_to"]
     except (json.JSONDecodeError, TypeError):
         pass
-    return None
+    return None

jaf/core/parallel_agents.py

@@ -25,13 +25,14 @@ from .types import (
 )
 from .agent_tool import create_agent_tool, AgentToolInput
 
-Ctx = TypeVar('Ctx')
-Out = TypeVar('Out')
+Ctx = TypeVar("Ctx")
+Out = TypeVar("Out")
 
 
 @dataclass
 class ParallelAgentGroup:
     """Configuration for a group of agents to be executed in parallel."""
+
     name: str
     agents: List[Agent[Ctx, Out]]
     shared_input: bool = True  # Whether all agents receive the same input
@@ -44,6 +45,7 @@ class ParallelAgentGroup:
 @dataclass
 class ParallelExecutionConfig:
     """Configuration for parallel agent execution."""
+
     groups: List[ParallelAgentGroup]
     inter_group_execution: str = "sequential"  # "sequential" or "parallel"
     global_timeout: Optional[float] = None
@@ -52,66 +54,67 @@ class ParallelExecutionConfig:
 
 class ParallelAgentsTool:
     """Tool that executes multiple agent groups in parallel."""
-    
+
     def __init__(
         self,
         config: ParallelExecutionConfig,
         tool_name: str = "execute_parallel_agents",
-        tool_description: str = "Execute multiple agents in parallel groups"
+        tool_description: str = "Execute multiple agents in parallel groups",
     ):
         self.config = config
         self.tool_name = tool_name
         self.tool_description = tool_description
-        
+
         # Create tool schema
         self.schema = ToolSchema(
             name=tool_name,
             description=tool_description,
             parameters=AgentToolInput,
-            timeout=config.global_timeout
+            timeout=config.global_timeout,
         )
         self.source = ToolSource.NATIVE
         self.metadata = {"source": "parallel_agents", "groups": len(config.groups)}
-    
+
     async def execute(self, args: AgentToolInput, context: Ctx) -> str:
         """Execute all configured agent groups."""
         try:
             if self.config.inter_group_execution == "parallel":
                 # Execute all groups in parallel
-                group_results = await asyncio.gather(*[
-                    self._execute_group(group, args.input, context) 
-                    for group in self.config.groups
-                ])
+                group_results = await asyncio.gather(
+                    *[
+                        self._execute_group(group, args.input, context)
+                        for group in self.config.groups
+                    ]
+                )
             else:
                 # Execute groups sequentially
                 group_results = []
                 for group in self.config.groups:
                     result = await self._execute_group(group, args.input, context)
                     group_results.append(result)
-            
+
             # Combine results from all groups
             final_result = {
                 "parallel_execution_results": {
                     group.name: result for group, result in zip(self.config.groups, group_results)
                 },
                 "execution_mode": self.config.inter_group_execution,
-                "total_groups": len(self.config.groups)
+                "total_groups": len(self.config.groups),
             }
-            
+
             return json.dumps(final_result, indent=2)
-            
+
         except Exception as e:
-            return json.dumps({
-                "error": "parallel_execution_failed",
-                "message": f"Failed to execute parallel agents: {str(e)}",
-                "groups_attempted": len(self.config.groups)
-            })
-    
+            return json.dumps(
+                {
+                    "error": "parallel_execution_failed",
+                    "message": f"Failed to execute parallel agents: {str(e)}",
+                    "groups_attempted": len(self.config.groups),
+                }
+            )
+
     async def _execute_group(
-        self, 
-        group: ParallelAgentGroup, 
-        input_text: str, 
-        context: Ctx
+        self, group: ParallelAgentGroup, input_text: str, context: Ctx
     ) -> Dict[str, Any]:
         """Execute a single group of agents in parallel."""
         try:
@@ -123,10 +126,10 @@ class ParallelAgentsTool:
                     tool_name=f"run_{agent.name.lower().replace(' ', '_')}",
                     tool_description=f"Execute the {agent.name} agent",
                     timeout=group.timeout,
-                    preserve_session=self.config.preserve_session
+                    preserve_session=self.config.preserve_session,
                 )
                 agent_tools.append((agent.name, tool))
-            
+
             # Execute all agents in the group in parallel
             if group.shared_input:
                 # All agents get the same input
@@ -140,16 +143,15 @@ class ParallelAgentsTool:
                     tool.execute(AgentToolInput(input=input_text), context)
                     for _, tool in agent_tools
                 ]
-            
+
             # Execute with timeout if specified
             if group.timeout:
                 results = await asyncio.wait_for(
-                    asyncio.gather(*tasks, return_exceptions=True),
-                    timeout=group.timeout
+                    asyncio.gather(*tasks, return_exceptions=True), timeout=group.timeout
                 )
             else:
                 results = await asyncio.gather(*tasks, return_exceptions=True)
-            
+
             # Process results
             agent_results = {}
             for (agent_name, _), result in zip(agent_tools, results):
@@ -157,61 +159,54 @@ class ParallelAgentsTool:
                     agent_results[agent_name] = {
                         "error": True,
                         "message": str(result),
-                        "type": type(result).__name__
+                        "type": type(result).__name__,
                     }
                 else:
-                    agent_results[agent_name] = {
-                        "success": True,
-                        "result": result
-                    }
-            
+                    agent_results[agent_name] = {"success": True, "result": result}
+
             # Apply result aggregation
             aggregated_result = self._aggregate_results(group, agent_results)
-            
+
             return {
                 "group_name": group.name,
                 "agent_count": len(group.agents),
                 "individual_results": agent_results,
                 "aggregated_result": aggregated_result,
-                "execution_time_ms": None  # Could be added with timing
+                "execution_time_ms": None,  # Could be added with timing
             }
-            
+
         except asyncio.TimeoutError:
             return {
                 "group_name": group.name,
                 "error": "timeout",
                 "message": f"Group {group.name} execution timed out after {group.timeout} seconds",
-                "agent_count": len(group.agents)
+                "agent_count": len(group.agents),
             }
         except Exception as e:
             return {
                 "group_name": group.name,
                 "error": "execution_failed",
                 "message": str(e),
-                "agent_count": len(group.agents)
+                "agent_count": len(group.agents),
             }
-    
+
     def _aggregate_results(
-        self, 
-        group: ParallelAgentGroup, 
-        agent_results: Dict[str, Any]
+        self, group: ParallelAgentGroup, agent_results: Dict[str, Any]
     ) -> Union[str, Dict[str, Any]]:
         """Aggregate results from parallel agent execution."""
         successful_results = [
-            result["result"] for result in agent_results.values() 
+            result["result"]
+            for result in agent_results.values()
             if result.get("success") and "result" in result
         ]
-        
+
         if not successful_results:
             return {"error": "no_successful_results", "message": "All agents failed"}
-        
+
         if group.result_aggregation == "first":
             return successful_results[0]
         elif group.result_aggregation == "combine":
-            return {
-                "combined_results": successful_results,
-                "result_count": len(successful_results)
-            }
+            return {"combined_results": successful_results, "result_count": len(successful_results)}
         elif group.result_aggregation == "majority":
             # Simple majority logic - could be enhanced
             if len(successful_results) >= len(group.agents) // 2 + 1:
@@ -233,11 +228,11 @@ def create_parallel_agents_tool(
     tool_description: str = "Execute multiple agents in parallel groups",
     inter_group_execution: str = "sequential",
     global_timeout: Optional[float] = None,
-    preserve_session: bool = False
+    preserve_session: bool = False,
 ) -> Tool:
     """
     Create a tool that executes multiple agent groups in parallel.
-    
+
     Args:
         groups: List of parallel agent groups to execute
         tool_name: Name of the tool
@@ -245,7 +240,7 @@ def create_parallel_agents_tool(
         inter_group_execution: How to execute groups ("sequential" or "parallel")
         global_timeout: Global timeout for all executions
         preserve_session: Whether to preserve session across agent calls
-        
+
     Returns:
         A Tool that can execute parallel agent groups
     """
@@ -253,9 +248,9 @@ def create_parallel_agents_tool(
         groups=groups,
         inter_group_execution=inter_group_execution,
         global_timeout=global_timeout,
-        preserve_session=preserve_session
+        preserve_session=preserve_session,
     )
-    
+
     return ParallelAgentsTool(config, tool_name, tool_description)
 
 
@@ -265,11 +260,11 @@ def create_simple_parallel_tool(
     tool_name: str = "execute_parallel_agents",
     shared_input: bool = True,
     result_aggregation: str = "combine",
-    timeout: Optional[float] = None
+    timeout: Optional[float] = None,
 ) -> Tool:
     """
     Create a simple parallel agents tool from a list of agents.
-    
+
     Args:
         agents: List of agents to execute in parallel
         group_name: Name for the parallel group
@@ -277,7 +272,7 @@ def create_simple_parallel_tool(
         shared_input: Whether all agents receive the same input
         result_aggregation: How to aggregate results ("combine", "first", "majority")
         timeout: Timeout for parallel execution
-        
+
     Returns:
         A Tool that executes all agents in parallel
     """
@@ -286,18 +281,19 @@ def create_simple_parallel_tool(
         agents=agents,
         shared_input=shared_input,
         result_aggregation=result_aggregation,
-        timeout=timeout
+        timeout=timeout,
     )
-    
+
     return create_parallel_agents_tool([group], tool_name=tool_name)
 
 
 # Convenience functions for common parallel execution patterns
 
+
 def create_language_specialists_tool(
     language_agents: Dict[str, Agent],
     tool_name: str = "consult_language_specialists",
-    timeout: Optional[float] = 300.0
+    timeout: Optional[float] = 300.0,
 ) -> Tool:
     """Create a tool that consults multiple language specialists in parallel."""
     group = ParallelAgentGroup(
@@ -306,13 +302,13 @@ def create_language_specialists_tool(
         shared_input=True,
         result_aggregation="combine",
         timeout=timeout,
-        metadata={"languages": list(language_agents.keys())}
+        metadata={"languages": list(language_agents.keys())},
     )
-    
+
     return create_parallel_agents_tool(
-        [group], 
+        [group],
         tool_name=tool_name,
-        tool_description="Consult multiple language specialists in parallel"
+        tool_description="Consult multiple language specialists in parallel",
     )
 
 
@@ -320,7 +316,7 @@ def create_domain_experts_tool(
     expert_agents: Dict[str, Agent],
     tool_name: str = "consult_domain_experts",
     result_aggregation: str = "combine",
-    timeout: Optional[float] = 60.0
+    timeout: Optional[float] = 60.0,
 ) -> Tool:
     """Create a tool that consults multiple domain experts in parallel."""
     group = ParallelAgentGroup(
@@ -329,11 +325,9 @@ def create_domain_experts_tool(
         shared_input=True,
         result_aggregation=result_aggregation,
         timeout=timeout,
-        metadata={"domains": list(expert_agents.keys())}
+        metadata={"domains": list(expert_agents.keys())},
     )
-    
+
     return create_parallel_agents_tool(
-        [group],
-        tool_name=tool_name,
-        tool_description="Consult multiple domain experts in parallel"
-    )
+        [group], tool_name=tool_name, tool_description="Consult multiple domain experts in parallel"
+    )