fix: protect result-writing loops from CancelledError and catch CancelledError in tool execution

Harden the orchestrator's result-writing and tool-execution loops against
CancelledError to prevent orphaned tool_calls that break the conversation
state.

When a CancelledError escapes a result-writing loop, the assistant message
is committed without the corresponding tool result. The LLM sees a
tool_use without a tool_result on the next turn, causing a protocol
violation or infinite retry loop.

This fix catches CancelledError at two levels:
- In the result-writing loop, ensuring partial results are committed
- In tool execution, ensuring the tool result is always recorded

Rebased on main to pick up the defensive getattr access pattern for
tool call attributes.

Companion fixes already merged in loop-streaming#14 and loop-events#5.

Fixes: microsoft-amplifier/amplifier-support#46

🤖 Generated with [Amplifier](https://github.com/microsoft/amplifier)

Co-Authored-By: Amplifier <240397093+microsoft-amplifier@users.noreply.github.com>

Author: sadlilas

amplifier_module_loop_basic/__init__.py

@@ -487,7 +487,7 @@ async def execute_single_tool(
                                     result_content = result.get_serialized_output()
                                 return (tool_call_id, result_content)
 
-                            except Exception as te:
+                            except (Exception, asyncio.CancelledError) as te:
                                 # Emit error event
                                 await hooks.emit(
                                     TOOL_ERROR,
@@ -524,19 +524,28 @@ async def execute_single_tool(
                         )
                     except asyncio.CancelledError:
                         # Immediate cancellation (second Ctrl+C) - synthesize cancelled results
-                        # for ALL tool_calls to maintain tool_use/tool_result pairing
+                        # for ALL tool_calls to maintain tool_use/tool_result pairing.
+                        # Protect from further CancelledError using kernel
+                        # catch-continue-reraise pattern so all results are written.
                         logger.info(
                             "Tool execution cancelled - synthesizing cancelled results"
                         )
                         for tc in tool_calls:
-                            if hasattr(context, "add_message"):
-                                await context.add_message(
-                                    {
-                                        "role": "tool",
-                                        "tool_call_id": getattr(tc, "id", None)
-                                        or tc.get("id"),
-                                        "content": f'{{"error": "Tool execution was cancelled by user", "cancelled": true, "tool": "{getattr(tc, "name", None) or tc.get("tool")}"}}',
-                                    }
+                            try:
+                                if hasattr(context, "add_message"):
+                                    await context.add_message(
+                                        {
+                                            "role": "tool",
+                                            "tool_call_id": getattr(tc, "id", None)
+                                            or tc.get("id"),
+                                            "content": f'{{"error": "Tool execution was cancelled by user", "cancelled": true, "tool": "{getattr(tc, "name", None) or tc.get("tool")}"}}',
+                                        }
+                                    )
+                            except asyncio.CancelledError:
+                                logger.info(
+                                    "CancelledError during synthetic result write - "
+                                    "completing remaining writes to prevent "
+                                    "orphaned tool_calls"
                                 )
                         # Re-raise to let the cancellation propagate
                         raise
@@ -546,15 +555,30 @@ async def execute_single_tool(
                         # MUST add tool results to context before returning
                         # Otherwise we leave orphaned tool_calls without matching tool_results
                         # which violates provider API contracts (Anthropic, OpenAI)
+                        # Protect from CancelledError using kernel catch-continue-reraise
+                        # pattern (coordinator.cleanup, hooks.emit) so all results are
+                        # written even if force-cancel arrives mid-loop.
+                        _cancel_error = None
                         for tool_call_id, content in tool_results:
-                            if hasattr(context, "add_message"):
-                                await context.add_message(
-                                    {
-                                        "role": "tool",
-                                        "tool_call_id": tool_call_id,
-                                        "content": content,
-                                    }
-                                )
+                            try:
+                                if hasattr(context, "add_message"):
+                                    await context.add_message(
+                                        {
+                                            "role": "tool",
+                                            "tool_call_id": tool_call_id,
+                                            "content": content,
+                                        }
+                                    )
+                            except asyncio.CancelledError:
+                                if _cancel_error is None:
+                                    _cancel_error = asyncio.CancelledError()
+                                    logger.info(
+                                        "CancelledError during tool result write - "
+                                        "completing remaining writes to prevent "
+                                        "orphaned tool_calls"
+                                    )
+                        if _cancel_error is not None:
+                            raise _cancel_error
                         await hooks.emit(
                             ORCHESTRATOR_COMPLETE,
                             {
@@ -566,15 +590,30 @@ async def execute_single_tool(
                         return final_content
 
                     # Add all tool results to context in original order (deterministic)
+                    # Protect from CancelledError using kernel catch-continue-reraise
+                    # pattern so all results are written even if force-cancel arrives
+                    # mid-loop.
+                    _cancel_error = None
                     for tool_call_id, content in tool_results:
-                        if hasattr(context, "add_message"):
-                            await context.add_message(
-                                {
-                                    "role": "tool",
-                                    "tool_call_id": tool_call_id,
-                                    "content": content,
-                                }
-                            )
+                        try:
+                            if hasattr(context, "add_message"):
+                                await context.add_message(
+                                    {
+                                        "role": "tool",
+                                        "tool_call_id": tool_call_id,
+                                        "content": content,
+                                    }
+                                )
+                        except asyncio.CancelledError:
+                            if _cancel_error is None:
+                                _cancel_error = asyncio.CancelledError()
+                                logger.info(
+                                    "CancelledError during tool result write - "
+                                    "completing remaining writes to prevent "
+                                    "orphaned tool_calls"
+                                )
+                    if _cancel_error is not None:
+                        raise _cancel_error
 
                     # After executing tools, continue loop to get final response
                     iteration += 1