Preserve Rust permission handler compatibility

Add a separate attributed permission handler path so clients can forward decision context without changing the existing PermissionResult enum or PermissionHandler contract.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 79152db2-4cc7-4777-983a-655fae5b68c9

Author: Aymen Furter

rust/src/handler.rs

@@ -15,6 +15,8 @@
 //! [`Tool::with_handler`](crate::types::Tool::with_handler) on entries passed to
 //! [`SessionConfig::with_tools`](crate::types::SessionConfig::with_tools).
 
+use std::sync::Arc;
+
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 
@@ -38,28 +40,35 @@ use crate::types::{
 /// approve-for-session, approve-permanently, user-not-available, …) or
 /// [`PermissionResult::NoResult`], which tells the SDK to suppress its
 /// response so another connected client can answer instead.
-#[non_exhaustive]
+///
+/// ```
+/// use github_copilot_sdk::handler::PermissionResult;
+///
+/// fn is_decision(result: PermissionResult) -> bool {
+///     match result {
+///         PermissionResult::Decision(_) => true,
+///         PermissionResult::NoResult => false,
+///     }
+/// }
+/// ```
 #[derive(Debug, Clone)]
 pub enum PermissionResult {
     /// Send a permission decision on the wire.
     Decision(PermissionDecision),
-    /// Send a permission decision annotated with the context describing how
-    /// and where it was reached, so the runtime can attribute
-    /// auto-approval telemetry to the responding surface.
-    ///
-    /// The context is informational only — it never changes permission
-    /// behavior.
-    AttributedDecision {
-        /// The decision to send on the wire.
-        decision: PermissionDecision,
-        /// Context describing how and where the decision was reached.
-        context: PermissionDecisionContext,
-    },
     /// Decline to respond to this request, allowing another connected
     /// client to answer instead. The SDK suppresses the response.
     NoResult,
 }
 
+/// A permission result with optional context describing how it was reached.
+#[derive(Debug, Clone)]
+pub struct AttributedPermissionResult {
+    /// The permission result.
+    pub result: PermissionResult,
+    /// Context describing how and where the decision was reached.
+    pub context: Option<PermissionDecisionContext>,
+}
+
 impl PermissionResult {
     /// Approve this single request.
     pub fn approve_once() -> Self {
@@ -92,8 +101,7 @@ impl PermissionResult {
     /// Attach provenance describing how and where this decision was made,
     /// so the runtime can attribute auto-approval telemetry.
     ///
-    /// Applying this to an already-attributed decision replaces the
-    /// previous context. It is a no-op on [`PermissionResult::NoResult`].
+    /// It is a no-op on [`PermissionResult::NoResult`].
     ///
     /// ```rust,no_run
     /// # use github_copilot_sdk::handler::PermissionResult;
@@ -108,16 +116,71 @@ impl PermissionResult {
     ///     surface: PermissionDecisionSurface::Sdk,
     /// });
     /// ```
-    pub fn with_context(self, context: PermissionDecisionContext) -> Self {
-        match self {
-            Self::Decision(decision) | Self::AttributedDecision { decision, .. } => {
-                Self::AttributedDecision { decision, context }
-            }
-            Self::NoResult => Self::NoResult,
+    pub fn with_context(self, context: PermissionDecisionContext) -> AttributedPermissionResult {
+        let context = match self {
+            Self::Decision(_) => Some(context),
+            Self::NoResult => None,
+        };
+        AttributedPermissionResult {
+            result: self,
+            context,
+        }
+    }
+}
+
+impl AttributedPermissionResult {
+    /// Replace the context describing how this decision was reached.
+    pub fn with_context(mut self, context: PermissionDecisionContext) -> Self {
+        if matches!(self.result, PermissionResult::Decision(_)) {
+            self.context = Some(context);
+        }
+        self
+    }
+}
+
+impl From<PermissionResult> for AttributedPermissionResult {
+    fn from(result: PermissionResult) -> Self {
+        Self {
+            result,
+            context: None,
         }
     }
 }
 
+/// Handler for permission requests that also reports how the decision was made.
+#[async_trait]
+pub trait AttributedPermissionHandler: Send + Sync + 'static {
+    /// Resolve a permission request and report how it was decided.
+    async fn handle(
+        &self,
+        session_id: SessionId,
+        request_id: RequestId,
+        data: PermissionRequestData,
+    ) -> AttributedPermissionResult;
+}
+
+struct UnattributedHandler(Arc<dyn PermissionHandler>);
+
+#[async_trait]
+impl AttributedPermissionHandler for UnattributedHandler {
+    async fn handle(
+        &self,
+        session_id: SessionId,
+        request_id: RequestId,
+        data: PermissionRequestData,
+    ) -> AttributedPermissionResult {
+        PermissionHandler::handle(&*self.0, session_id, request_id, data)
+            .await
+            .into()
+    }
+}
+
+pub(crate) fn attributed(
+    handler: Arc<dyn PermissionHandler>,
+) -> Arc<dyn AttributedPermissionHandler> {
+    Arc::new(UnattributedHandler(handler))
+}
+
 impl From<PermissionDecision> for PermissionResult {
     fn from(value: PermissionDecision) -> Self {
         Self::Decision(value)

rust/src/permission.rs

@@ -16,7 +16,9 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 
-use crate::handler::{PermissionHandler, PermissionResult, permission_handler_failure};
+use crate::handler::{
+    AttributedPermissionHandler, PermissionHandler, PermissionResult, permission_handler_failure,
+};
 use crate::types::{PermissionRequestData, RequestId, SessionId};
 
 /// Return a [`PermissionHandler`] that approves requests when managed settings
@@ -93,12 +95,16 @@ impl std::fmt::Debug for Policy {
 ///   `requestPermission: false`).
 pub(crate) fn resolve_handler(
     handler: Option<Arc<dyn PermissionHandler>>,
+    attributed_handler: Option<Arc<dyn AttributedPermissionHandler>>,
     policy: Option<Policy>,
-) -> Option<Arc<dyn PermissionHandler>> {
-    match (handler, policy) {
-        (_, Some(policy)) => Some(Arc::new(PolicyHandler { policy })),
-        (Some(h), None) => Some(h),
-        (None, None) => None,
+) -> Option<Arc<dyn AttributedPermissionHandler>> {
+    match (handler, attributed_handler, policy) {
+        (_, _, Some(policy)) => Some(crate::handler::attributed(Arc::new(PolicyHandler {
+            policy,
+        }))),
+        (_, Some(h), None) => Some(h),
+        (Some(h), None, None) => Some(crate::handler::attributed(h)),
+        (None, None, None) => None,
     }
 }
 
@@ -227,12 +233,13 @@ mod tests {
             }
         }
         let resolved =
-            resolve_handler(Some(Arc::new(AlwaysApprove)), Some(Policy::DenyAll)).unwrap();
+            resolve_handler(Some(Arc::new(AlwaysApprove)), None, Some(Policy::DenyAll)).unwrap();
         // Policy wins -- the AlwaysApprove handler is discarded.
         assert!(matches!(
             resolved
                 .handle(SessionId::from("s"), RequestId::new("1"), data())
-                .await,
+                .await
+                .result,
             PermissionResult::Decision(crate::types::PermissionDecision::Reject(_))
         ));
     }
@@ -251,17 +258,18 @@ mod tests {
                 PermissionResult::approve_once()
             }
         }
-        let resolved = resolve_handler(Some(Arc::new(H)), None).unwrap();
+        let resolved = resolve_handler(Some(Arc::new(H)), None, None).unwrap();
         assert!(matches!(
             resolved
                 .handle(SessionId::from("s"), RequestId::new("1"), data())
-                .await,
+                .await
+                .result,
             PermissionResult::Decision(crate::types::PermissionDecision::ApproveOnce(_))
         ));
     }
 
     #[test]
     fn resolve_handler_with_neither_returns_none() {
-        assert!(resolve_handler(None, None).is_none());
+        assert!(resolve_handler(None, None, None).is_none());
     }
 }

rust/src/session.rs

@@ -20,8 +20,8 @@ use crate::generated::session_events::{
     SessionCanvasClosedData, SessionErrorData, SessionEventType,
 };
 use crate::handler::{
-    AutoModeSwitchHandler, AutoModeSwitchResponse, ElicitationHandler, ExitPlanModeHandler,
-    McpAuthHandler, McpAuthRequest, McpAuthResult, PermissionHandler, PermissionResult,
+    AttributedPermissionHandler, AutoModeSwitchHandler, AutoModeSwitchResponse, ElicitationHandler,
+    ExitPlanModeHandler, McpAuthHandler, McpAuthRequest, McpAuthResult, PermissionResult,
     UserInputHandler, UserInputResponse,
 };
 use crate::hooks::SessionHooks;
@@ -56,7 +56,7 @@ const TOOL_SEARCH_TOOL_NAME: &str = "tool_search_tool";
 /// are derived from these fields.
 #[derive(Clone)]
 pub(crate) struct SessionHandlers {
-    pub permission: Option<Arc<dyn PermissionHandler>>,
+    pub permission: Option<Arc<dyn AttributedPermissionHandler>>,
     pub managed_settings_enabled: bool,
     pub elicitation: Option<Arc<dyn ElicitationHandler>>,
     pub mcp_auth: Option<Arc<dyn McpAuthHandler>>,
@@ -902,6 +902,7 @@ impl Client {
 
         let permission_handler = crate::permission::resolve_handler(
             runtime.permission_handler.take(),
+            runtime.attributed_permission_handler.take(),
             runtime.permission_policy.take(),
         );
         let handlers = SessionHandlers {
@@ -1175,6 +1176,7 @@ impl Client {
 
         let permission_handler = crate::permission::resolve_handler(
             runtime.permission_handler.take(),
+            runtime.attributed_permission_handler.take(),
             runtime.permission_policy.take(),
         );
         let handlers = SessionHandlers {
@@ -1580,15 +1582,14 @@ fn permission_request_data(
 fn notification_permission_payload(result: &PermissionResult) -> Option<Value> {
     match result {
         PermissionResult::NoResult => None,
-        PermissionResult::Decision(decision)
-        | PermissionResult::AttributedDecision { decision, .. } => Some(
+        PermissionResult::Decision(decision) => Some(
             serde_json::to_value(decision).expect("serializing permission decision should succeed"),
         ),
     }
 }
 
 /// Build the full `session.permissions.handlePendingPermissionRequest`
-/// params for a [`PermissionResult`].
+/// params for an attributed permission result.
 ///
 /// `decisionContext` is a sibling of `result` and is only present when the
 /// handler attributed the decision — omitting it preserves legacy behavior.
@@ -1597,15 +1598,15 @@ fn notification_permission_payload(result: &PermissionResult) -> Option<Value> {
 fn permission_response_params(
     session_id: &SessionId,
     request_id: &RequestId,
-    result: &PermissionResult,
+    result: &crate::handler::AttributedPermissionResult,
 ) -> Option<Value> {
-    let result_value = notification_permission_payload(result)?;
+    let result_value = notification_permission_payload(&result.result)?;
     let mut params = serde_json::json!({
         "sessionId": session_id,
         "requestId": request_id,
         "result": result_value,
     });
-    if let PermissionResult::AttributedDecision { context, .. } = result {
+    if let Some(context) = &result.context {
         params["decisionContext"] =
             serde_json::to_value(context).expect("serializing decision context should succeed");
     }
@@ -2641,7 +2642,7 @@ mod tests {
         let params = permission_response_params(
             &SessionId::from("session-1"),
             &RequestId::from("permission-1"),
-            &PermissionResult::approve_once(),
+            &PermissionResult::approve_once().into(),
         )
         .unwrap();
         assert_eq!(
@@ -2686,18 +2687,17 @@ mod tests {
             permission_response_params(
                 &SessionId::from("session-1"),
                 &RequestId::from("permission-1"),
-                &PermissionResult::NoResult,
+                &PermissionResult::NoResult.into(),
             )
             .is_none()
         );
     }
 
     #[test]
     fn with_context_is_a_no_op_on_no_result() {
-        assert!(matches!(
-            PermissionResult::no_result().with_context(attribution_context()),
-            PermissionResult::NoResult
-        ));
+        let result = PermissionResult::no_result().with_context(attribution_context());
+        assert!(matches!(result.result, PermissionResult::NoResult));
+        assert!(result.context.is_none());
     }
 
     #[test]