[Audric Schiltknecht (audricschiltknecht)]

Motivation and Context

When a handoff occurs, the HandoffRequest was not passed the original cancellation token, leading to the creation of a separate token. This made the OrchestrationResult impossible to cancel/stop the runtime as the agent are testing for the wrong token in the HandoffAgentActor::_handle_request_message() method.

Description

Simply pass the cancellation token in the publish_message() call.

Contribution Checklist

• The code builds clean without any errors or warnings
• The PR follows the SK Contribution Guidelines and the pre-submission formatting script raises no violations
• All unit tests pass, and I have added new tests where possible
• I didn't break anyone 😄

[Audric Schiltknecht (audricschiltknecht)]

I would need a bit of help to add testing (if possible at all). I was looking at inspiration from the test_invoke_with_handoff_function_call, but I'm not understanding how I could simulate that the agent does not complete the task.

[Evan Mattson (moonbox3)]

Audric Schiltknecht (@audricschiltknecht) please have a look at this test:

@pytest.mark.skipif(                                                                                                                                                                               
    sys.version_info < (3, 11),                                                                                                                                                                    
    reason="Python 3.10 doesn't bound the original function provided to the wraps argument of the patch object.",
)                                                                                                                                                                                                  
async def test_invoke_cancel_during_handoff():                  
    """Test that cancellation propagates through handoff requests.                                                                                                                                 
                                                                                                                                                                                                   
    When agent A hands off to agent B and the orchestration is cancelled,
    agent B should not process the handoff request because the cancellation                                                                                                                        
    token should be propagated with the HandoffRequestMessage.                                                                                                                                     
    """
    agent_b = MockAgent()                                                                                                                                                                          
    agent_a = MockAgentWithHandoffFunctionCall(agent_b)                                                                                                                                            
 
    with (                                                                                                                                                                                         
        patch.object(MockAgent, "invoke_stream", wraps=MockAgent.invoke_stream, autospec=True) as mock_invoke_stream,
    ):                                                                                                                                                                                             
        runtime = InProcessRuntime()
        runtime.start()                                                                                                                                                                            
                                                                
        try:
            orchestration = HandoffOrchestration(
                members=[agent_a, agent_b],                                                                                                                                                        
                handoffs={
                    agent_a.name: {agent_b.name: "test"},                                                                                                                                          
                    agent_b.name: {agent_a.name: "test"},       
                },                                                                                                                                                                                 
            )                                                   
            orchestration_result = await orchestration.invoke(task="test_message", runtime=runtime)                                                                                                
                                                                                                                                                                                                   
            # Wait long enough for agent_a to complete its handoff (~0.1s)                                                                                                                         
            # but cancel before agent_b processes the request                                                                                                                                      
            await asyncio.sleep(0.15)                                                                                                                                                              
            orchestration_result.cancel()                       
        finally:                                                                                                                                                                                   
            await runtime.stop_when_idle()                      
                                                                                                                                                                                                   
        # Agent B should NOT have been invoked because the cancellation token
        # was propagated with the HandoffRequestMessage and the ActorBase                                                                                                                          
        # checks `ctx.cancellation_token.is_cancelled()` before processing.                                                                                                                        
        # Without the fix, agent B receives a fresh (non-cancelled) token
        # and processes the request anyway.                                                                                                                                                        
        assert mock_invoke_stream.call_count == 0

[Copilot]

Copilot review overview

🟡 Changes recommended

Add regression coverage verifying cancellation after a handoff is published.

Review effort: Lite
Findings: 1

Open (1)

• Add regression test for token preservation after handoff cancellation · New

What changed in this PR

Fixes cancellation-token propagation for Python handoff requests.

Changes:

• Reuses the orchestration cancellation token during handoffs.
• Preserves cancellation behavior across agent transitions.

File	Description
python/​semantic_kernel/​agents/​orchestration/​handoffs.py	Propagates the cancellation token during handoff requests.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.