wip

Author: nikomatsakis

src/sacp/src/jsonrpc/responder.rs

@@ -12,10 +12,10 @@ use crate::{JrConnectionCx, role::JrRole};
 ///
 /// Responders are composed using [`ChainResponder`] and run in parallel
 /// when the connection is active.
-pub trait JrResponder<Role: JrRole>: Send {
+#[expect(async_fn_in_trait)]
+pub trait JrResponder<Role: JrRole> {
     /// Run this responder to completion.
-    fn run(self, cx: JrConnectionCx<Role>)
-    -> impl Future<Output = Result<(), crate::Error>> + Send;
+    async fn run(self, cx: JrConnectionCx<Role>) -> Result<(), crate::Error>;
 }
 
 /// A no-op responder that completes immediately.

src/sacp/src/mcp_server/builder.rs

@@ -140,8 +140,7 @@ where
     where
         P: JsonSchema + DeserializeOwned + 'static + Send,
         R: JsonSchema + Serialize + 'static + Send,
-        F: FnMut(P, McpContext<Role>) -> Fut + Send + Sync,
-        Fut: std::future::Future<Output = Result<R, crate::Error>> + Send,
+        F: AsyncFnMut(P, McpContext<Role>) -> Result<R, crate::Error>,
     {
         struct ToolFnTool<P, R, Role: JrRole> {
             name: String,

src/sacp/src/mcp_server/responder.rs

@@ -1,7 +1,5 @@
 //! MCP-specific responder types.
 
-use std::future::Future;
-
 use futures::{StreamExt, channel::mpsc};
 
 use crate::{JrConnectionCx, JrRole, jsonrpc::responder::JrResponder, mcp_server::McpContext};
@@ -20,13 +18,12 @@ pub struct ToolFnResponder<F, P, R, Role: JrRole> {
     pub(crate) call_rx: mpsc::Receiver<ToolCall<P, R, Role>>,
 }
 
-impl<F, P, R, Role, Fut> JrResponder<Role> for ToolFnResponder<F, P, R, Role>
+impl<F, P, R, Role> JrResponder<Role> for ToolFnResponder<F, P, R, Role>
 where
     Role: JrRole,
     P: Send,
     R: Send,
-    F: FnMut(P, McpContext<Role>) -> Fut + Send,
-    Fut: Future<Output = Result<R, crate::Error>> + Send,
+    F: AsyncFnMut(P, McpContext<Role>) -> Result<R, crate::Error>,
 {
     async fn run(mut self, _cx: JrConnectionCx<Role>) -> Result<(), crate::Error> {
         while let Some(ToolCall {

src/sacp/src/session.rs

@@ -145,10 +145,21 @@ where
         .await
     }
 
-    /// Send the request to create the session.
-    pub async fn send_request(self) -> Result<ActiveSession<Role>, crate::Error>
+    /// Send the request to create the session and return a handle.
+    /// This is an alternative to [`Self::run_session`] that avoids rightward
+    /// drift but at the cost of requiring MCP servers that are `Send` and
+    /// don't access data from the surrounding scope.
+    ///
+    /// # Parameters
+    ///
+    /// * `run_responder`: this is typically just `Responder::run`;
+    ///   the need for this parameter is a workaround for Rust limitations.
+    pub async fn send_request<F>(
+        self,
+        run_responder: impl FnOnce(Responder, JrConnectionCx<Role>) -> F,
+    ) -> Result<ActiveSession<Role>, crate::Error>
     where
-        Responder: 'static,
+        F: Future<Output = Result<(), crate::Error>> + Send + 'static,
     {
         let response = self
             .connection
@@ -157,7 +168,7 @@ where
             .await?;
 
         let cx = self.connection.clone();
-        self.connection.spawn(self.responder.run(cx))?;
+        self.connection.spawn(run_responder(self.responder, cx))?;
 
         self.connection
             .attach_session(response, self.dynamic_handler_registrations)

src/yopo/src/lib.rs

@@ -2,13 +2,13 @@
 //!
 //! Provides a convenient API for running one-shot prompts against SACP components.
 
-use sacp::ClientToAgent;
 use sacp::schema::{
     AudioContent, ContentBlock, EmbeddedResourceResource, ImageContent, InitializeRequest,
     RequestPermissionOutcome, RequestPermissionRequest, RequestPermissionResponse,
     SessionNotification, TextContent, VERSION as PROTOCOL_VERSION,
 };
 use sacp::util::MatchMessage;
+use sacp::{ClientToAgent, JrResponder};
 use sacp::{Component, Handled, MessageCx, UntypedMessage};
 use std::path::PathBuf;
 
@@ -112,7 +112,10 @@ pub async fn prompt_with_callback(
                 .block_task()
                 .await?;
 
-            let mut session = cx.build_session(PathBuf::from(".")).send_request().await?;
+            let mut session = cx
+                .build_session(PathBuf::from("."))
+                .send_request(JrResponder::run)
+                .await?;
 
             session.send_prompt(prompt_text)?;