Phase H redo: migrate tests, examples, and scenarios to per-trait handler API

Mechanical migration of all consumers to the new optional handler-trait
API introduced in 455a17b:

- rust/tests/session_test.rs: ~30 SessionHandler impls split into the
  corresponding PermissionHandler / ElicitationHandler / UserInputHandler /
  ExitPlanModeHandler / AutoModeSwitchHandler / ToolHandler impls. Tests
  that called handler.on_event(...) directly now call handler.handle(...)
  on the appropriate trait. The legacy tool.call direct-RPC test was
  dropped; equivalent coverage is already provided by
  external_tool_requested_dispatches_to_handler_and_responds.
- rust/tests/e2e/*: per-trait migration; with_handler(...) -> the matching
  with_*_handler builder.
- rust/examples/*: same migration.
- test/scenarios/**/rust/src/main.rs: same migration.

Also fixes a bug in Client::create_session / Client::resume_session
where to_wire() was called after .take()-ing all handler fields, so the
derived wire flags (requestPermission, requestElicitation, hooks, etc.)
were always false. Computing the wire payload now happens before the
takes.

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

Author: SteveSandersonMS

rust/README.md

@@ -13,39 +13,29 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use async_trait::async_trait;
-use github_copilot_sdk::handler::{
-    HandlerEvent, HandlerResponse, PermissionResult, SessionHandler, UserInputResponse,
-};
-use github_copilot_sdk::types::{MessageOptions, SessionConfig, SessionEvent};
+use github_copilot_sdk::handler::{ApproveAllHandler, UserInputHandler, UserInputResponse};
+use github_copilot_sdk::types::{MessageOptions, SessionConfig, SessionEvent, SessionId};
 use github_copilot_sdk::{Client, ClientOptions};
 
-/// Handler that prints assistant message deltas as they stream in
-/// and auto-approves permissions.
-struct ChatHandler;
+/// User input handler that prompts on stdin.
+struct StdinUserInputHandler;
 
 #[async_trait]
-impl SessionHandler for ChatHandler {
-    async fn on_event(&self, event: HandlerEvent) -> HandlerResponse {
-        match event {
-            HandlerEvent::SessionEvent { event, .. } => {
-                print_event(&event);
-                HandlerResponse::Ok
-            }
-            HandlerEvent::PermissionRequest { .. } => {
-                HandlerResponse::Permission(PermissionResult::Approved)
-            }
-            HandlerEvent::UserInput { question, .. } => {
-                // Prompt the user on behalf of the agent.
-                print!("\n[agent asks] {question}\n> ");
-                io::stdout().flush().ok();
-                let answer = read_line().unwrap_or_default();
-                HandlerResponse::UserInput(Some(UserInputResponse {
-                    answer,
-                    was_freeform: true,
-                }))
-            }
-            _ => HandlerResponse::Ok,
-        }
+impl UserInputHandler for StdinUserInputHandler {
+    async fn handle(
+        &self,
+        _session_id: SessionId,
+        question: String,
+        _choices: Option<Vec<String>>,
+        _allow_freeform: Option<bool>,
+    ) -> Option<UserInputResponse> {
+        print!("\n[agent asks] {question}\n> ");
+        io::stdout().flush().ok();
+        let answer = read_line()?;
+        Some(UserInputResponse {
+            answer,
+            was_freeform: true,
+        })
     }
 }
 
@@ -91,9 +81,11 @@ async fn main() -> Result<(), github_copilot_sdk::Error> {
     let client = Client::start(ClientOptions::default()).await?;
 
     let config = {
-        let mut cfg = SessionConfig::default();
+        let mut cfg = SessionConfig::default()
+            .with_permission_handler(Arc::new(ApproveAllHandler))
+            .with_user_input_handler(Arc::new(StdinUserInputHandler));
         cfg.streaming = Some(true);
-        cfg.with_handler(Arc::new(ChatHandler))
+        cfg
     };
     let session = client.create_session(config).await?;
 
@@ -102,6 +94,14 @@ async fn main() -> Result<(), github_copilot_sdk::Error> {
         session.id()
     );
 
+    // Spawn a task to print streamed assistant deltas as session events arrive.
+    let mut events = session.subscribe();
+    tokio::spawn(async move {
+        while let Ok(event) = events.recv().await {
+            print_event(&event);
+        }
+    });
+
     loop {
         print!("> ");
         io::stdout().flush().ok();

rust/examples/chat.rs

@@ -103,7 +103,7 @@ async fn main() -> Result<(), github_copilot_sdk::Error> {
 
     // hooks: true is set automatically when a hooks handler is provided.
     let config = SessionConfig::default()
-        .with_handler(Arc::new(ApproveAllHandler))
+        .with_permission_handler(Arc::new(ApproveAllHandler))
         .with_hooks(Arc::new(AuditHooks));
     let session = client.create_session(config).await?;
 

rust/examples/hooks.rs

@@ -63,7 +63,7 @@ async fn main() -> Result<(), github_copilot_sdk::Error> {
         }
     });
 
-    let config = SessionConfig::default().with_handler(Arc::new(ApproveAllHandler));
+    let config = SessionConfig::default().with_permission_handler(Arc::new(ApproveAllHandler));
     let session = client.create_session(config).await?;
     println!("[client] session created: {}", session.id());
 

rust/examples/lifecycle_observer.rs

@@ -125,7 +125,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let session = client
         .create_session(
             SessionConfig::default()
-                .with_handler(Arc::new(ApproveAllHandler))
+                .with_permission_handler(Arc::new(ApproveAllHandler))
                 .with_session_fs_provider(provider),
         )
         .await?;

rust/examples/session_fs.rs

@@ -30,9 +30,7 @@ use async_trait::async_trait;
 #[cfg(feature = "derive")]
 use github_copilot_sdk::handler::ApproveAllHandler;
 #[cfg(feature = "derive")]
-use github_copilot_sdk::tool::{
-    JsonSchema, ToolHandler, ToolHandlerRouter, schema_for, tool_parameters,
-};
+use github_copilot_sdk::tool::{JsonSchema, ToolHandler, schema_for, tool_parameters};
 #[cfg(feature = "derive")]
 use github_copilot_sdk::types::{MessageOptions, SessionConfig, Tool, ToolInvocation, ToolResult};
 #[cfg(feature = "derive")]
@@ -145,19 +143,18 @@ impl ToolHandler for RollDiceTool {
 #[cfg(feature = "derive")]
 #[tokio::main]
 async fn main() -> Result<(), github_copilot_sdk::Error> {
-    let router = ToolHandlerRouter::new(
-        vec![Box::new(GetWeatherTool), Box::new(RollDiceTool)],
-        Arc::new(ApproveAllHandler),
-    );
-    let tools = router.tools();
-    let handler = Arc::new(router);
+    let tool_handlers: Vec<Arc<dyn ToolHandler>> =
+        vec![Arc::new(GetWeatherTool), Arc::new(RollDiceTool)];
+    let tools: Vec<Tool> = tool_handlers.iter().map(|h| h.tool()).collect();
 
     let client = Client::start(ClientOptions::default()).await?;
 
     let config = {
-        let mut cfg = SessionConfig::default();
+        let mut cfg = SessionConfig::default()
+            .with_permission_handler(Arc::new(ApproveAllHandler))
+            .with_tool_handlers(tool_handlers);
         cfg.tools = Some(tools);
-        cfg.with_handler(handler)
+        cfg
     };
     let session = client.create_session(config).await?;
 

rust/examples/tool_server.rs

@@ -229,4 +229,4 @@ mod tests {
             .await;
         assert!(matches!(result, PermissionResult::Denied));
     }
-}
+}

rust/src/handler.rs

@@ -138,7 +138,8 @@ mod tests {
     async fn approve_all_approves() {
         let h = approve_all();
         assert!(matches!(
-            h.handle(SessionId::from("s"), RequestId::new("1"), data()).await,
+            h.handle(SessionId::from("s"), RequestId::new("1"), data())
+                .await,
             PermissionResult::Approved
         ));
     }
@@ -147,7 +148,8 @@ mod tests {
     async fn deny_all_denies() {
         let h = deny_all();
         assert!(matches!(
-            h.handle(SessionId::from("s"), RequestId::new("1"), data()).await,
+            h.handle(SessionId::from("s"), RequestId::new("1"), data())
+                .await,
             PermissionResult::Denied
         ));
     }
@@ -156,7 +158,8 @@ mod tests {
     async fn approve_if_consults_predicate() {
         let h = approve_if(|d| d.extra.get("tool").and_then(|v| v.as_str()) != Some("shell"));
         assert!(matches!(
-            h.handle(SessionId::from("s"), RequestId::new("1"), data()).await,
+            h.handle(SessionId::from("s"), RequestId::new("1"), data())
+                .await,
             PermissionResult::Denied
         ));
     }
@@ -213,4 +216,4 @@ mod tests {
     fn resolve_handler_with_neither_returns_none() {
         assert!(resolve_handler(None, None).is_none());
     }
-}
+}

rust/src/permission.rs

@@ -31,8 +31,7 @@ use crate::types::{
     ElicitationResult, ExitPlanModeData, GetMessagesResponse, MessageOptions,
     PermissionRequestData, RequestId, ResumeSessionConfig, SectionOverride, SessionCapabilities,
     SessionConfig, SessionEvent, SessionId, SetModelOptions, SystemMessageConfig, ToolInvocation,
-    ToolResult, ToolResultExpanded, TraceContext, UiInputOptions,
-    ensure_attachment_display_names,
+    ToolResult, ToolResultExpanded, TraceContext, UiInputOptions, ensure_attachment_display_names,
 };
 use crate::{Client, Error, JsonRpcResponse, SessionError, SessionEventNotification, error_codes};
 
@@ -53,19 +52,6 @@ pub(crate) struct SessionHandlers {
     pub tools: Arc<HashMap<String, Arc<dyn crate::tool::ToolHandler>>>,
 }
 
-impl SessionHandlers {
-    pub(crate) fn empty() -> Self {
-        Self {
-            permission: None,
-            elicitation: None,
-            user_input: None,
-            exit_plan_mode: None,
-            auto_mode_switch: None,
-            tools: Arc::new(HashMap::new()),
-        }
-    }
-}
-
 /// Shared state between a [`Session`] and its event loop, used by [`Session::send_and_wait`].
 struct IdleWaiter {
     tx: oneshot::Sender<Result<Option<SessionEvent>, Error>>,
@@ -794,6 +780,19 @@ impl Client {
     /// broadcast (and silently skips dispatch if one arrives anyway).
     pub async fn create_session(&self, mut config: SessionConfig) -> Result<Session, Error> {
         let total_start = Instant::now();
+        let session_id = config
+            .session_id
+            .clone()
+            .unwrap_or_else(|| SessionId::from(uuid::Uuid::new_v4().to_string()));
+        config.session_id = Some(session_id.clone());
+        if config.hooks_handler.is_some() && config.hooks.is_none() {
+            config.hooks = Some(true);
+        }
+        if let Some(transforms) = config.transform.clone() {
+            inject_transform_sections(&mut config, transforms.as_ref());
+        }
+        let wire = config.to_wire(session_id.clone());
+
         let permission_handler = crate::permission::resolve_handler(
             config.permission_handler.take(),
             config.permission_policy.take(),
@@ -841,18 +840,6 @@ impl Client {
             ));
         }
 
-        if hooks.is_some() && config.hooks.is_none() {
-            config.hooks = Some(true);
-        }
-        if let Some(ref transforms) = transforms {
-            inject_transform_sections(&mut config, transforms.as_ref());
-        }
-        let session_id = config
-            .session_id
-            .clone()
-            .unwrap_or_else(|| SessionId::from(uuid::Uuid::new_v4().to_string()));
-        config.session_id = Some(session_id.clone());
-        let wire = config.to_wire(session_id.clone());
         let mut params = serde_json::to_value(&wire)?;
         let trace_ctx = self.resolve_trace_context().await;
         inject_trace_context(&mut params, &trace_ctx);
@@ -948,6 +935,15 @@ impl Client {
     /// fields are unset.
     pub async fn resume_session(&self, mut config: ResumeSessionConfig) -> Result<Session, Error> {
         let total_start = Instant::now();
+        let session_id = config.session_id.clone();
+        if config.hooks_handler.is_some() && config.hooks.is_none() {
+            config.hooks = Some(true);
+        }
+        if let Some(transforms) = config.transform.clone() {
+            inject_transform_sections_resume(&mut config, transforms.as_ref());
+        }
+        let wire = config.to_wire();
+
         let permission_handler = crate::permission::resolve_handler(
             config.permission_handler.take(),
             config.permission_policy.take(),
@@ -995,14 +991,6 @@ impl Client {
             ));
         }
 
-        if hooks.is_some() && config.hooks.is_none() {
-            config.hooks = Some(true);
-        }
-        if let Some(ref transforms) = transforms {
-            inject_transform_sections_resume(&mut config, transforms.as_ref());
-        }
-        let session_id = config.session_id.clone();
-        let wire = config.to_wire();
         let mut params = serde_json::to_value(&wire)?;
         let trace_ctx = self.resolve_trace_context().await;
         inject_trace_context(&mut params, &trace_ctx);
@@ -1568,8 +1556,7 @@ async fn handle_notification(
                         tool_name = %tool_name,
                         "ToolHandler::call dispatch"
                     );
-                    let result_value =
-                        serde_json::to_value(tool_result).unwrap_or(Value::Null);
+                    let result_value = serde_json::to_value(tool_result).unwrap_or(Value::Null);
                     let rpc_start = Instant::now();
                     let _ = client
                         .call(
@@ -2179,8 +2166,10 @@ mod tests {
             json!({ "kind": "reject" })
         );
         assert_eq!(
-            serde_json::to_value(permission_request_response(&PermissionResult::UserNotAvailable))
-                .expect("serializing fallback permission response should succeed"),
+            serde_json::to_value(permission_request_response(
+                &PermissionResult::UserNotAvailable
+            ))
+            .expect("serializing fallback permission response should succeed"),
             json!({ "kind": "reject" })
         );
     }

rust/src/session.rs

@@ -335,7 +335,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::{PermissionRequestData, RequestId, SessionId};
+    use crate::types::SessionId;
 
     struct EchoTool;