release: sync copilot-sdk-cpp v0.4.1

Re-pins to @github/copilot 1.0.84-6 (github/copilot-sdk e5c53790) and closes the
two lifecycle gaps carried over from the previous release.

Read this before upgrading: NOT binary-compatible

  Despite the patch-level version, relinking a prebuilt library against 0.4.0
  headers is unsafe. SessionEventType gained three values ahead of Unknown, so
  Unknown renumbers from 144 to 147, and struct layouts changed. Recompiling
  against these headers is safe and requires no source changes.

Fixes

- Session teardown now issues session.detach rather than session.destroy,
  following upstream. Session::detach() returns the runtime's {success, error};
  destroy() is kept, implemented on top of it, and drops a soft failure because
  its signature cannot carry one. A declined detach is not raised -- teardown
  should not fail because the runtime already considers a session gone.

- Host tool invocations are cancelled when the connection closes. Tool handlers
  run on a background task and answer with session.tools.handlePendingToolCall;
  because session destruction waits on those tasks, a handler finishing during
  shutdown would answer over a transport already being torn down.
  Client::stop() and force_stop() now cancel first, so the result is dropped
  instead. The handler itself is your code and is not interrupted.

  Session::cancel_pending_tool_invocations() and pending_tool_invocations() are
  public, so the behaviour is observable rather than implicit.

Protocol

  Regenerated from CLI 1.0.84-6: API definitions 1293 -> 1306, event definitions
  576 -> 582, event variants 144 -> 147. Three new skill.* events are mapped
  rather than degrading to SessionEventType::Unknown.

  RPC methods went 384 -> 383: sessions.registerExtensionToolsOnSession was
  removed upstream. Nothing in the hand-written API referenced it.

  The wire protocol is unchanged at version 3.

Suite: 468 tests, 0 failed.

Author: 0xeb

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.20)
-project(copilot_sdk_cpp VERSION 0.4.0 LANGUAGES CXX)
+project(copilot_sdk_cpp VERSION 0.4.1 LANGUAGES CXX)
 
 # Enable folder organization in IDEs
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)

include/copilot/events.hpp

@@ -3118,6 +3118,10 @@ enum class SessionEventType
     PermissionMessageAuthorizationDegraded,
     SessionMcpServerRemoved,
     SessionMcpServerNeedsReconnect,
+    // Added with the @github/copilot 1.0.84-6 re-pin (upstream e5c53790).
+    SkillInvokedRef,
+    SkillContextDelivered,
+    SkillContextDeliveredRef,
     Unknown
 };
 
@@ -3466,6 +3470,10 @@ inline SessionEvent parse_session_event(const json& j)
          SessionEventType::PermissionMessageAuthorizationDegraded},
         {"session.mcp_server_removed", SessionEventType::SessionMcpServerRemoved},
         {"session.mcp_server_needs_reconnect", SessionEventType::SessionMcpServerNeedsReconnect},
+        // @github/copilot 1.0.84-6 (upstream e5c53790).
+        {"skill.invoked_ref", SessionEventType::SkillInvokedRef},
+        {"skill.context_delivered", SessionEventType::SkillContextDelivered},
+        {"skill.context_delivered_ref", SessionEventType::SkillContextDeliveredRef},
     };
 
     auto it = type_map.find(event.type_string);

include/copilot/generated/api_types.hpp

@@ -9,7 +9,7 @@ namespace copilot::generated
 
 inline constexpr int kSdkProtocolVersion = 3;
 inline constexpr int kMinProtocolVersion = 2;
-inline constexpr std::string_view kOfficialSdkCommit = "f45c46fd1812f8bed5b4cbc250f47177c83068f0";
-inline constexpr std::string_view kOfficialSchemaPackageVersion = "1.0.84-5";
+inline constexpr std::string_view kOfficialSdkCommit = "e5c53790c6a8aa253aa3887ebb8958646bd60452";
+inline constexpr std::string_view kOfficialSchemaPackageVersion = "1.0.84-6";
 
 } // namespace copilot::generated

include/copilot/generated/protocol_version.hpp

@@ -8,18 +8,18 @@
 namespace copilot::generated::coverage
 {
 
-inline constexpr std::size_t kApiDefinitionCount = 1293;
-inline constexpr std::size_t kSessionEventDefinitionCount = 576;
+inline constexpr std::size_t kApiDefinitionCount = 1306;
+inline constexpr std::size_t kSessionEventDefinitionCount = 582;
 inline constexpr std::size_t kSharedDefinitionCount = 58;
-inline constexpr std::size_t kUniqueDefinitionCount = 1811;
-inline constexpr std::size_t kRpcMethodCount = 384;
-inline constexpr std::size_t kSessionEventVariantCount = 144;
-inline constexpr std::string_view kApiSchemaSha256 = "5835517c600d1661bb857aa74deeb2abd2cfb9ed1e69cdedd1402181ea9eca98";
-inline constexpr std::string_view kSessionEventsSchemaSha256 = "fded8ae9faa212cc84adae273c8b107a450b90ab66a723ee03e9057d41f8e4c5";
-inline constexpr std::string_view kApiDefinitionNamesSha256 = "374f18544d37959a909d1852524008b95b656b1db7f53890abc606cee8120077";
-inline constexpr std::string_view kSessionEventDefinitionNamesSha256 = "21e92237ac86ce0a8e6a2e1554369b83a413f9a6006c03d40f0709a409758ffc";
-inline constexpr std::string_view kRpcMethodNamesSha256 = "940bc904071d6292b0707fc71523fc78aad5cd73a2a1df8dc03f388bc1ef1b27";
-inline constexpr std::string_view kSessionEventWireTypesSha256 = "e149d65f991cac05fd210a93dd034d4bad7c4ba02e1bf443fb5c9b5af8850e33";
-inline constexpr std::string_view kSurfaceSha256 = "d8c46b04dd0fee2eee2552833266fa12a97b403667c9f541d59716e602229689";
+inline constexpr std::size_t kUniqueDefinitionCount = 1830;
+inline constexpr std::size_t kRpcMethodCount = 383;
+inline constexpr std::size_t kSessionEventVariantCount = 147;
+inline constexpr std::string_view kApiSchemaSha256 = "443958cfdccb9323b13c20ce5133817c1800b8e9e700ae3b9520bcc6f2a66340";
+inline constexpr std::string_view kSessionEventsSchemaSha256 = "d34b2b2af8f20c2118f1d07d1409bceac10d400c0878e987b9af68f903103d8c";
+inline constexpr std::string_view kApiDefinitionNamesSha256 = "1a0c4ed01b23fd47aa97d01ac99c29ba6861873c61d0f8d9e9b95c80ef293b95";
+inline constexpr std::string_view kSessionEventDefinitionNamesSha256 = "528849e2f18ec2429afb1ad0201b0a317c8be84ec6c6fa823a288da129b598e1";
+inline constexpr std::string_view kRpcMethodNamesSha256 = "37f118b1fbbb0f3442d0b366e3f4d73ebc5ba287b7dcb5ca75448dd2c86345dc";
+inline constexpr std::string_view kSessionEventWireTypesSha256 = "d45372a060c9f6851e5438ac8a5d14073dff77f44138dc2e6be51dc556bd979f";
+inline constexpr std::string_view kSurfaceSha256 = "02dd29c3d305ad86ecaabd8879afa5cd418039ac6f564819297a5c45c5384769";
 
 } // namespace copilot::generated::coverage

include/copilot/generated/schema_coverage.hpp

@@ -173,6 +173,7 @@ inline constexpr const char* kSessionGetMetadata  = "session.getMetadata";
 inline constexpr const char* kSessionDelete       = "session.delete";
 inline constexpr const char* kSessionGetLastId    = "session.getLastId";
 inline constexpr const char* kSessionDestroy      = "session.destroy";
+inline constexpr const char* kSessionDetach       = "session.detach";
 inline constexpr const char* kSessionSend         = "session.send";
 inline constexpr const char* kSessionAbort        = "session.abort";
 inline constexpr const char* kSessionGetMessages  = "session.getMessages";

include/copilot/generated/session_events.hpp

@@ -285,8 +285,45 @@ class Session : public std::enable_shared_from_this<Session>
     // Lifecycle
     // =========================================================================
 
-    /// Destroy the session on the server
-    /// @return Future that completes when destroyed
+    /// Stop answering host tool invocations on this session.
+    ///
+    /// A handler already running is user code on a background task and cannot be
+    /// interrupted; this ensures that when it returns, its result is dropped
+    /// instead of being sent as `session.tools.handlePendingToolCall` over a
+    /// connection that is closing. Called by Client during stop, mirroring
+    /// upstream github/copilot-sdk 53e74d81.
+    void cancel_pending_tool_invocations() noexcept;
+
+    /// Host tool invocations dispatched but not yet answered. Exposed so the
+    /// cancellation contract is observable from a test.
+    int pending_tool_invocations() const noexcept;
+
+    /// Outcome of detach(). Mirrors upstream's SessionDetachResponse.
+    struct DetachResult
+    {
+        /// Whether the runtime released the session.
+        bool success = false;
+        /// Runtime-supplied reason when `success` is false.
+        std::optional<std::string> error;
+        /// Full response, so fields not surfaced above stay reachable.
+        json raw;
+    };
+
+    /// Detach the session from this connection.
+    ///
+    /// Calls `session.detach`, which replaced `session.destroy` as the SDK
+    /// teardown RPC upstream (github/copilot-sdk fcffcdf0). A `success: false`
+    /// response is reported here rather than thrown: teardown should not fail
+    /// because the runtime declined to release a session.
+    std::future<DetachResult> detach();
+
+    /// Destroy the session on the server.
+    ///
+    /// Retained for source compatibility and implemented in terms of detach().
+    /// A soft failure (`success: false`) is **discarded** here because the
+    /// signature cannot carry it — call detach() directly if you need to know.
+    /// Transport and RPC errors still propagate.
+    /// @return Future that completes when the session has been detached
     std::future<void> destroy();
 
     /// Disconnect this SDK participant while leaving the session resumable.
@@ -451,6 +488,13 @@ class Session : public std::enable_shared_from_this<Session>
 
     std::mutex background_tasks_mutex_;
     std::vector<std::future<void>> background_tasks_;
+
+    /// Set when the connection is going away. A host tool handler already running
+    /// cannot be interrupted -- it is user code on a detached task -- but once it
+    /// returns we must not answer into a connection that is being torn down.
+    std::atomic<bool> tool_invocations_cancelled_{false};
+    /// Host tool invocations dispatched but not yet answered.
+    std::atomic<int> pending_tool_invocations_{0};
 };
 
 } // namespace copilot