⚡ Bolt: Parallelize session destruction in Python SDK

[AkCodes23]

⚡ Bolt Optimization: Parallel Session Destruction

This PR implements a performance improvement in the Python SDK by parallelizing the cleanup of active sessions when the client is stopped.

💡 What

• Modified CopilotClient.stop() in python/copilot/client.py to use asyncio.gather for session destruction.
• Implemented a destroy_with_retry helper function with up to 3 attempts and exponential backoff (100ms, 200ms).
• Matched the implementation logic of the Node.js SDK for cross-language consistency and robustness.

🎯 Why

Previously, the Python SDK destroyed sessions one by one. Since each session.destroy() call involves a JSON-RPC request over stdio/TCP, the total shutdown time was the sum of all session destruction latencies. For users with multiple active sessions, this caused a noticeable delay during application shutdown.

📊 Impact

• Shutdown Time: Reduced from $O(N \times \text{latency})$ to $O(\text{latency})$ where $N$ is the number of sessions.
• Measurable Result: Benchmark with 10 sessions and 100ms simulated latency showed a ~10x speedup (from 1.0s to 0.1s).
• Robustness: Transient network or pipe errors during shutdown are now handled with retries.

🔬 Measurement

The optimization was verified using a benchmark script benchmark_stop.py which mocked the JsonRpcClient to simulate latency. The results consistently showed a significant reduction in total time for multi-session scenarios.

Existing unit and E2E tests in the Python SDK were run and passed successfully.

---

PR created automatically by Jules for task 604084263500025276 started by @AkCodes23

[google-labs-jules]

👋 Jules, reporting for duty! I'm here to lend a hand with this pull request.

When you start a review, I'll add a 👀 emoji to each comment to let you know I've read it. I'll focus on feedback directed at me and will do my best to stay out of conversations between you and other bots or reviewers to keep the noise down.

I'll push a commit with your requested changes shortly after. Please note there might be a delay between these steps, but rest assured I'm on the job!

For more direct control, you can switch me to Reactive Mode. When this mode is on, I will only act on comments where you specifically mention me with @jules. You can find this option in the Pull Request section of your global Jules UI settings. You can always switch back!

New to Jules? Learn more at jules.google/docs.

---

For security, I will only act on instructions from the user who triggered this task.

[Copilot]

Pull request overview

Improves Python SDK shutdown performance by destroying active Copilot sessions concurrently (instead of sequentially) when CopilotClient.stop() is called, adding retry + backoff for robustness during teardown.

Changes:

• Parallelized session destruction in CopilotClient.stop() using asyncio.gather.
• Added destroy_with_retry() helper to retry session destruction up to 3 times with exponential backoff.
• Updated internal Bolt notes documenting the optimization.

Reviewed changes

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

File	Description
python/copilot/client.py	Parallelizes session cleanup during client shutdown and adds retry/backoff around session.destroy().
.jules/bolt.md	Documents the learning/action item for parallel session destruction in the Python SDK.

[Copilot]

CopilotClient.stop() now has new retry + parallel-destruction behavior, but there are no unit/E2E tests covering stop/cleanup semantics (success after retry, aggregated errors after 3 failures, and that it still closes the JSON-RPC client). Please add a test that creates multiple sessions and asserts destroy is invoked for all of them, including retry behavior when session.destroy() fails transiently.

[Copilot]

The Bolt note uses malformed big-O notation: "(N)$" and "(1)$" look like accidental LaTeX remnants and read incorrectly. Please change these to standard notation (e.g., O(N) and O(1)) so the guidance is unambiguous.

Suggested change

	**Learning:** Sequential cleanup of network-bound resources (like JSON-RPC sessions) leads to (N)$ shutdown time. Parallelizing with `asyncio.gather` reduces it to (1)$ relative to session count.
	**Learning:** Sequential cleanup of network-bound resources (like JSON-RPC sessions) leads to O(N) shutdown time. Parallelizing with `asyncio.gather` reduces it to O(1) relative to session count.