feat(rust): plumb CancellationToken through ToolInvocation for handler cancellation

[gimenete]

Summary

Implements issue #1433 for the Rust SDK: propagates cancellation to in-flight tool handlers when Session::abort() is called.

Changes

• types.rs: Add cancellation_token: CancellationToken field to ToolInvocation. Skipped during serde serialization/deserialization so it has no effect on the JSON wire format. Defaults to a fresh CancellationToken::new() (never-cancelled) so existing code constructing invocations directly continues to compile.

• session.rs:

  • Add tool_abort: Arc<ParkingLotMutex<CancellationToken>> to Session, initialized as a child of the session's shutdown token.
  • Session::abort() now cancels the current tool_abort token (which fires all child tokens held by in-flight handlers) and replaces it with a fresh child of shutdown, so subsequent tool invocations are not pre-cancelled.
  • Thread tool_abort through spawn_event_loop → handle_notification. Each ToolInvocation gets a fresh child token at dispatch time.

• tool.rs: Update test ToolInvocation constructions to use ..Default::default() for the new field; add two unit tests covering token cancellation semantics.

API

Handlers that opt in can check invocation.cancellation_token.is_cancelled() or select! on invocation.cancellation_token.cancelled():

impl ToolHandler for MyTool {
    async fn call(&self, inv: ToolInvocation) -> Result<ToolResult, Error> {
        tokio::select! {
            _ = inv.cancellation_token.cancelled() => {
                Err(Error::with_message(ErrorKind::Cancelled, "tool call aborted"))
            }
            result = do_work() => result,
        }
    }
}

Backwards compatibility

Handlers that don't consume the token continue to work unchanged. ToolInvocation is #[non_exhaustive] so adding the field is non-breaking for external consumers.

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

This PR adds cooperative cancellation for tool handlers by wiring a CancellationToken into each ToolInvocation and having Session::abort() signal all in-flight tool work.

Changes:

• Added cancellation_token: CancellationToken to ToolInvocation (skipped for serde) so handlers can stop early on abort.
• Implemented session-level tool-abort broadcast token that Session::abort() cancels and the event loop uses to derive per-invocation child tokens.
• Updated and extended Rust tests to use Default struct update syntax and to validate token cancellation behavior.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 3 comments.

File	Description
rust/src/types.rs	Extends ToolInvocation with a cancellation token and documents intended cancellation semantics.
rust/src/session.rs	Introduces a shared abort token, cancels it on abort(), and injects per-tool child tokens during dispatch.
rust/src/tool.rs	Updates tests for new ToolInvocation field and adds cancellation-token unit tests.

Comments suppressed due to low confidence (1)

rust/src/types.rs:1

• Adding a new public field to a public struct is a semver-breaking change for downstream callers that construct ToolInvocation via struct literals. If this crate has external consumers, consider mitigating by providing (and documenting) a constructor (e.g., ToolInvocation::new(...)) and encouraging struct update syntax, or by making the new field private with an accessor so future additions don’t force call-site changes.

//! Protocol types shared between the SDK and the GitHub Copilot CLI.