Cancel completed host tool invocations across SDKs

[stephentoub]

Host-owned external tool callbacks could continue running after the runtime had already completed or drained their request, wasting resources and risking stale responses. This adds request-scoped cancellation across every SDK language while preserving existing SendAndWait wait-only cancellation semantics.

Summary

• Track each external tool invocation by requestId and pass the language-native cancellation primitive to the host callback.
• Cancel pending callbacks when external_tool.completed arrives, when sessions or clients terminate, and when the transport closes unexpectedly.
• Atomically claim requests before responding so completion, teardown, duplicate clients, and late callback results cannot produce stale responses or leak cancellation handles.
• Preserve normal completion, timeout, and failed-disconnect retry behavior with existing runtimes; abort and suspend cancellation lights up when the runtime emits terminal completion events.
• Add focused lifecycle, race, retry, force-stop, connection-loss, and late-response coverage across .NET, Node.js, Python, Go, Java, and Rust.

Testing

• .NET: SDK build for netstandard2.0, net8.0, and net10.0; 57 focused lifetime tests.
• Node.js: 194 relevant tests, typecheck, and lint.
• Python: focused cancellation and shutdown tests plus Ruff.
• Rust: 130 session tests plus format, check, and Clippy.
• Go and Java changes were statically reviewed because those toolchains were unavailable locally.
• Repeated Claude Opus 5 full-diff reviews concluded CLEAN with high confidence.

Generated by Copilot

[Copilot]

Copilot review overview

🟡 Changes recommended

Six moderate cancellation and cleanup defects remain unresolved.

Once you've addressed the issues Copilot identified, you can request another Copilot review.

Review tier: Balanced
Findings: 6

New issues introduced by this change (6)

Severity	Finding
	dotnet/​src/​Client.cs — JsonRpc.Completion can be faulted by an abnormal transport/protocol failure. In that case this…
	dotnet/​src/​Session.cs — CancellationTokenSource.Cancel() runs registered callbacks synchronously. Because…
	java/​sdk/​src/​main/​java/​com/​github/​copilot/​CopilotSession.java — This drains only entries currently visible in the map and does not prevent a later insertion.…
	nodejs/​src/​session.ts — After a normal handler result or error, _claimExternalTool has already removed this controller,…
	rust/​src/​session.rs — This create path can return from the later register_mcp_auth_interest(...).await? before a…
	rust/​src/​session.rs — The event-loop shutdown path does not cancel this token. In particular,…

What changed in this PR

Adds request-scoped cancellation for host-owned external tool invocations across all six SDKs.

Changes:

• Cancels pending callbacks on completion, teardown, and connection loss.
• Atomically claims requests to prevent stale or duplicate responses.
• Adds lifecycle, race, retry, and cancellation coverage.

Required fixes:

• dotnet/src/Client.cs (moderate, 1 vote): Observe JsonRpc.Completion failures and continue cancellation cleanup.
• dotnet/src/Session.cs (moderate, 1 vote): Move synchronous token cancellation off the JSON-RPC read loop.
• java/.../CopilotSession.java (moderate, 1 vote): Prevent tool registration after force-stop draining begins.
• nodejs/src/session.ts (moderate, 1 vote): Always abort invocation controllers in both affected finally blocks.
• rust/src/session.rs:1619 (moderate, 1 vote): Cancel external-tool tasks during event-loop shutdown.
• rust/src/session.rs:1115 (moderate, 1 vote): Add cleanup protection for create-session registration failures.

File	Description
rust/​tests/​session_test.rs	Tests cancellation and connection-loss behavior.
rust/​src/​session.rs	Tracks and cancels tool futures; has two unresolved cleanup issues.
rust/​src/​jsonrpc.rs	Exposes connection-closure cancellation.
python/​test_session.py	Tests task cancellation and disconnect behavior.
python/​test_client.py	Tests client shutdown cleanup.
python/​copilot/​session.py	Tracks and claims external-tool tasks.
python/​copilot/​client.py	Cancels session work during teardown.
nodejs/​test/​external-tool-cancellation.test.ts	Covers cancellation, retries, duplicates, and late results.
nodejs/​test/​client.test.ts	Tests transport-close cancellation.
nodejs/​src/​types.ts	Exposes invocation abort signals.
nodejs/​src/​session.ts	Manages invocation controllers; final abort remains incomplete.
nodejs/​src/​client.ts	Handles connection-close cleanup.
java/​sdk/​src/​test/​java/​com/​github/​copilot/​SessionEventHandlingTest.java	Tests Java tool cancellation.
java/​sdk/​src/​test/​java/​com/​github/​copilot/​JsonRpcClientTest.java	Tests close-handler delivery.
java/​sdk/​src/​test/​java/​com/​github/​copilot/​CopilotClientTest.java	Tests force-stop cancellation.
java/​sdk/​src/​main/​java/​com/​github/​copilot/​JsonRpcClient.java	Adds connection-close callbacks.
java/​sdk/​src/​main/​java/​com/​github/​copilot/​CopilotSession.java	Tracks tool futures; force-stop has a registration race.
java/​sdk/​src/​main/​java/​com/​github/​copilot/​CopilotClient.java	Propagates teardown to sessions.
go/​types.go	Documents invocation-context cancellation.
go/​session.go	Implements request-scoped contexts and claiming.
go/​session_test.go	Tests completion-driven cancellation.
go/​client.go	Cancels tools during shutdown and connection loss.
go/​client_test.go	Tests client lifecycle cancellation.
dotnet/​test/​Unit/​ClientSessionLifetimeTests.cs	Covers cancellation and teardown scenarios.
dotnet/​src/​Session.cs	Adds cancellable tool calls; cancellation can block dispatch.
dotnet/​src/​Client.cs	Propagates teardown; faulted completion can skip cleanup.
CHANGELOG.md	Documents cross-SDK cancellation behavior.

Suppressed comments (1)

nodejs/src/session.ts:2068

• A concurrent caller returns immediately while the first destroy RPC is still pending. If that RPC later fails, the second caller has already observed a successful disconnect() even though the session remains connected and retryable. Store the in-flight disconnect promise and have concurrent callers await the same operation, clearing it on failure.

        if (this.disconnected || this.disconnecting) {
            return;
        }
        this.disconnecting = true;

---

💡 Configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[SteveSandersonMS]

Thanks for the solid cross-SDK fix and for keeping behavior aligned across runtimes.

I added follow-up standalone E2E tests in commit b6ac7f4 to cover the concrete cancellation scenario (long-running external tool + session termination) across all six SDKs:

• .NET: dispose path
• Node/Python/Go/Rust/Java: disconnect/close path

Locally, the new targeted tests pass in Node, Python, Go, Rust, and .NET. Java test execution is blocked in this environment by Maven TLS trust-chain resolution of org.sonatype.central:central-publishing-maven-plugin, so we should rely on CI for the Java lane signal.

Given this, I recommend we proceed to merge once CI is green.

[github-actions]

Cross-SDK Consistency Review — PR #2509

Reviewed the authoritative diff (get_files + get_diff) across all six SDKs for the "cancellation for host-owned external tools" feature.

Result: Consistent. This PR implements the feature in parallel across all six SDKs with idiomatic-per-language cancellation primitives, matching the CHANGELOG description precisely:

SDK	Cancellation primitive	Notes
.NET	CancellationToken threaded through AIFunction.InvokeAsync / HandlePendingToolCallAsync	Cancelled on ForceStopAsync, connection close, and session DisposeAsync
Node.js	ToolInvocation.signal (AbortSignal), new optional field in types.ts	Cancelled on session._markDisconnected() and connection close
Go	ToolInvocation.TraceContext cancellation	Doc comment updated to warn that background work must derive its own lifetime — good catch, avoids a footgun
Java	Cancels the CompletableFuture returned by the tool handler	New PendingExternalTool state machine handles the start/cancel race cleanly
Python	Cancels the asyncio.Task running the handler	Handles cross-thread cancellation via call_soon_threadsafe from the connection-close path
Rust	Races the handler future against a CancellationToken via tokio::select! (drops the future on cancel)	PendingExternalToolGuard cleanly claims/removes pending entries

All six implementations:

• Cancel pending external tool handlers on ExternalToolCompletedEvent/broadcast equivalent (server said "done, no need to keep working")
• Cancel all pending tools on session disconnect/dispose and on client force-stop/connection-close
• Include unit tests and matching E2E snapshot-based tests (test/snapshots/external_tool_cancellation/*.yaml used by dotnet, with each SDK's own E2E test hitting the same scenarios)
• Guard against double-completion races (claim/remove-once patterns) consistently

No cross-SDK gaps or naming inconsistencies found. This is a good example of maintaining feature parity across the six language implementations.

Generated by SDK Consistency Review Agent for #2509 · copilot · sonnet50 · 38.1 AIC · ⌖ 12 AIC · ⊞ 9.7K · ◷