Merge pull request agentclientprotocol#105 from nikomatsakis/main

feat(deps)!: upgrade agent-client-protocol-schema to 0.10.5

Author: nikomatsakis

Cargo.toml

@@ -20,7 +20,7 @@ tokio = { version = "1.48", features = ["full"] }
 tokio-util = { version = "0.7", features = ["compat"] }
 
 # Protocol
-agent-client-protocol-schema = "0.6.3"
+agent-client-protocol-schema = "0.10.5"
 
 # Serialization
 serde = { version = "1.0", features = ["derive"] }

src/elizacp/src/lib.rs

@@ -78,16 +78,10 @@ impl ElizaAgent {
         tracing::debug!("New session request with cwd: {:?}", request.cwd);
 
         // Generate a new session ID
-        let session_id = SessionId(Arc::from(uuid::Uuid::new_v4().to_string()));
+        let session_id = SessionId::new(uuid::Uuid::new_v4().to_string());
         self.create_session(&session_id, request.mcp_servers);
 
-        let response = NewSessionResponse {
-            session_id,
-            modes: None,
-            meta: None,
-        };
-
-        request_cx.respond(response)
+        request_cx.respond(NewSessionResponse::new(session_id))
     }
 
     async fn handle_load_session(
@@ -100,12 +94,7 @@ impl ElizaAgent {
         // For Eliza, we just create a fresh session with no MCP servers
         self.create_session(&request.session_id, vec![]);
 
-        let response = LoadSessionResponse {
-            modes: None,
-            meta: None,
-        };
-
-        request_cx.respond(response)
+        request_cx.respond(LoadSessionResponse::new())
     }
 
     /// Process the prompt and send response - this runs in a spawned task
@@ -171,20 +160,13 @@ impl ElizaAgent {
             ?final_response,
             "Eliza sending SessionNotification"
         );
-        cx.send_notification(SessionNotification {
-            session_id: session_id.clone(),
-            update: SessionUpdate::AgentMessageChunk(ContentChunk {
-                content: final_response.into(),
-                meta: None,
-            }),
-            meta: None,
-        })?;
+        cx.send_notification(SessionNotification::new(
+            session_id.clone(),
+            SessionUpdate::AgentMessageChunk(ContentChunk::new(final_response.into())),
+        ))?;
 
         // Complete the request
-        request_cx.respond(PromptResponse {
-            stop_reason: StopReason::EndTurn,
-            meta: None,
-        })
+        request_cx.respond(PromptResponse::new(StopReason::EndTurn))
     }
 
     /// Helper function to execute an operation with an MCP client
@@ -213,34 +195,33 @@ impl ElizaAgent {
         let mcp_server = mcp_servers
             .iter()
             .find(|server| match server {
-                McpServer::Stdio { name, .. } => name == server_name,
-                McpServer::Http { name, .. } => name == server_name,
-                McpServer::Sse { name, .. } => name == server_name,
+                McpServer::Stdio(stdio) => stdio.name == server_name,
+                McpServer::Http(http) => http.name == server_name,
+                McpServer::Sse(sse) => sse.name == server_name,
+                _ => false,
             })
             .ok_or_else(|| anyhow::anyhow!("MCP server '{}' not found", server_name))?;
 
         // Spawn MCP client based on server type
         match mcp_server {
-            McpServer::Stdio {
-                command, args, env, ..
-            } => {
+            McpServer::Stdio(stdio) => {
                 tracing::debug!(
-                    command = ?command,
-                    args = ?args,
+                    command = ?stdio.command,
+                    args = ?stdio.args,
                     server_name = %server_name,
                     "Starting MCP client"
                 );
 
                 // Create MCP client by spawning the process
                 let mcp_client = ()
-                    .serve(TokioChildProcess::new(Command::new(command).configure(
-                        |cmd| {
-                            cmd.args(args);
-                            for env_var in env {
+                    .serve(TokioChildProcess::new(
+                        Command::new(&stdio.command).configure(|cmd| {
+                            cmd.args(&stdio.args);
+                            for env_var in &stdio.env {
                                 cmd.env(&env_var.name, &env_var.value);
                             }
-                        },
-                    ))?)
+                        }),
+                    )?)
                     .await?;
 
                 tracing::debug!("MCP client connected");
@@ -250,18 +231,18 @@ impl ElizaAgent {
 
                 Ok(result)
             }
-            McpServer::Http { url, .. } => {
+            McpServer::Http(http) => {
                 use rmcp::transport::StreamableHttpClientTransport;
 
                 tracing::debug!(
-                    url = %url,
+                    url = %http.url,
                     server_name = %server_name,
                     "Starting HTTP MCP client"
                 );
 
                 // Create HTTP MCP client
                 let mcp_client =
-                    ().serve(StreamableHttpClientTransport::from_uri(url.as_str()))
+                    ().serve(StreamableHttpClientTransport::from_uri(http.url.as_str()))
                         .await?;
 
                 tracing::debug!("HTTP MCP client connected");
@@ -271,7 +252,8 @@ impl ElizaAgent {
 
                 Ok(result)
             }
-            McpServer::Sse { .. } => Err(anyhow::anyhow!("SSE MCP servers not yet supported")),
+            McpServer::Sse(_) => Err(anyhow::anyhow!("SSE MCP servers not yet supported")),
+            _ => Err(anyhow::anyhow!("Unknown MCP server type")),
         }
     }
 
@@ -394,18 +376,10 @@ impl Component<sacp::link::AgentToClient> for ElizaAgent {
                 async |initialize: InitializeRequest, request_cx, _cx| {
                     tracing::debug!("Received initialize request");
 
-                    request_cx.respond(InitializeResponse {
-                        protocol_version: initialize.protocol_version,
-                        agent_capabilities: AgentCapabilities {
-                            load_session: Default::default(),
-                            prompt_capabilities: Default::default(),
-                            mcp_capabilities: Default::default(),
-                            meta: Default::default(),
-                        },
-                        auth_methods: Default::default(),
-                        agent_info: Default::default(),
-                        meta: Default::default(),
-                    })
+                    request_cx.respond(
+                        InitializeResponse::new(initialize.protocol_version)
+                            .agent_capabilities(AgentCapabilities::new()),
+                    )
                 },
                 sacp::on_receive_request!(),
             )

src/elizacp/tests/mcp_tool_invocation.rs

@@ -5,8 +5,8 @@ use expect_test::expect;
 use sacp::Component;
 use sacp::link::UntypedLink;
 use sacp::schema::{
-    ContentBlock, InitializeRequest, McpServer, NewSessionRequest, PromptRequest,
-    SessionNotification, TextContent,
+    ContentBlock, InitializeRequest, McpServer, McpServerStdio, NewSessionRequest, PromptRequest,
+    ProtocolVersion, SessionNotification, TextContent,
 };
 use sacp_test::test_binaries;
 use std::path::PathBuf;
@@ -61,41 +61,29 @@ async fn test_elizacp_mcp_tool_call() -> Result<(), sacp::Error> {
         })
         .run_until(transport, async |client_cx| {
             // Initialize
-            let _init_response = recv(client_cx.send_request(InitializeRequest {
-                protocol_version: Default::default(),
-                client_capabilities: Default::default(),
-                meta: None,
-                client_info: None,
-            }))
-            .await?;
+            let _init_response =
+                recv(client_cx.send_request(InitializeRequest::new(ProtocolVersion::LATEST)))
+                    .await?;
 
             // Create session with an MCP server
             // Use the mcp-echo-server from sacp-test (pre-built binary)
             let mcp_server_binary = test_binaries::mcp_echo_server_binary();
-            let session_response = recv(client_cx.send_request(NewSessionRequest {
-                cwd: PathBuf::from("/tmp"),
-                mcp_servers: vec![McpServer::Stdio {
-                    name: "test".to_string(),
-                    command: mcp_server_binary,
-                    args: vec![],
-                    env: vec![],
-                }],
-                meta: None,
-            }))
+            let session_response = recv(client_cx.send_request(
+                NewSessionRequest::new(PathBuf::from("/tmp")).mcp_servers(vec![McpServer::Stdio(
+                    McpServerStdio::new("test".to_string(), mcp_server_binary),
+                )]),
+            ))
             .await?;
 
             let session_id = session_response.session_id;
 
             // Send a prompt to invoke the MCP tool
-            let _prompt_response = recv(client_cx.send_request(PromptRequest {
-                session_id: session_id.clone(),
-                prompt: vec![ContentBlock::Text(TextContent {
-                    annotations: None,
-                    text: r#"Use tool test::echo with {"message": "Hello from test!"}"#.to_string(),
-                    meta: None,
-                })],
-                meta: None,
-            }))
+            let _prompt_response = recv(client_cx.send_request(PromptRequest::new(
+                session_id.clone(),
+                vec![ContentBlock::Text(TextContent::new(
+                    r#"Use tool test::echo with {"message": "Hello from test!"}"#.to_string(),
+                ))],
+            )))
             .await?;
 
             Ok(())

src/sacp-conductor/src/conductor.rs

@@ -971,7 +971,7 @@ where
             .if_request(async |_request: InitializeProxyRequest, request_cx| {
                 request_cx.respond_with_error(
                     sacp::Error::invalid_request()
-                        .with_data("initialize/proxy requests are only sent by the conductor"),
+                        .data("initialize/proxy requests are only sent by the conductor"),
                 )
             })
             .await
@@ -1021,7 +1021,7 @@ where
             .if_request(async |_request: InitializeProxyRequest, request_cx| {
                 request_cx.respond_with_error(
                     sacp::Error::invalid_request()
-                        .with_data("initialize/proxy requests are only sent by the conductor"),
+                        .data("initialize/proxy requests are only sent by the conductor"),
                 )
             })
             .await
@@ -1514,8 +1514,7 @@ impl ConductorLink for ConductorToClient {
         instantiator: Self::Instantiator,
         responder: &mut ConductorResponder<Self>,
     ) -> Result<MessageCx, sacp::Error> {
-        let invalid_request =
-            || Error::invalid_request().with_data("expected `initialize` request");
+        let invalid_request = || Error::invalid_request().data("expected `initialize` request");
 
         // Not yet initialized - expect an initialize request.
         // Error if we get anything else.
@@ -1614,8 +1613,7 @@ impl ConductorLink for ConductorToConductor {
         instantiator: Self::Instantiator,
         responder: &mut ConductorResponder<Self>,
     ) -> Result<MessageCx, sacp::Error> {
-        let invalid_request =
-            || Error::invalid_request().with_data("expected `initialize` request");
+        let invalid_request = || Error::invalid_request().data("expected `initialize` request");
 
         // Not yet initialized - expect an InitializeProxy request.
         // Error if we get anything else.

src/sacp-conductor/src/conductor/mcp_bridge.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 use futures::{SinkExt, channel::mpsc};
-use sacp::schema::McpServer;
+use sacp::schema::{McpServer, McpServerHttp, McpServerStdio};
 use sacp::{self, JrLink};
 use sacp::{JrConnectionCx, MessageCx};
 use tokio::net::TcpListener;
@@ -67,18 +67,21 @@ impl McpBridgeListeners {
     ) -> Result<(), sacp::Error> {
         use sacp::schema::McpServer;
 
-        let McpServer::Http { name, url, headers } = mcp_server else {
+        let McpServer::Http(http) = mcp_server else {
             return Ok(());
         };
 
-        if !url.starts_with("acp:") {
+        if !http.url.starts_with("acp:") {
             return Ok(());
         }
 
-        if !headers.is_empty() {
+        if !http.headers.is_empty() {
             return Err(sacp::Error::internal_error());
         }
 
+        let name = &http.name;
+        let url = &http.url;
+
         info!(
             server_name = name,
             acp_url = url,
@@ -114,22 +117,24 @@ impl McpBridgeListeners {
         info!(acp_url = acp_url, tcp_port, "Bound listener for MCP bridge");
 
         let new_server = match mcp_bridge_mode {
-            crate::McpBridgeMode::Stdio { conductor_command } => McpServer::Stdio {
-                name: server_name.to_string(),
-                command: PathBuf::from(&conductor_command[0]),
-                args: conductor_command[1..]
-                    .iter()
-                    .cloned()
-                    .chain(vec!["mcp".to_string(), format!("{tcp_port}")])
-                    .collect(),
-                env: Default::default(),
-            },
-
-            crate::McpBridgeMode::Http => McpServer::Http {
-                name: server_name.to_string(),
-                url: format!("http://localhost:{tcp_port}"),
-                headers: vec![],
-            },
+            crate::McpBridgeMode::Stdio { conductor_command } => McpServer::Stdio(
+                McpServerStdio::new(
+                    server_name.to_string(),
+                    PathBuf::from(&conductor_command[0]),
+                )
+                .args(
+                    conductor_command[1..]
+                        .iter()
+                        .cloned()
+                        .chain(vec!["mcp".to_string(), format!("{tcp_port}")])
+                        .collect::<Vec<_>>(),
+                ),
+            ),
+
+            crate::McpBridgeMode::Http => McpServer::Http(McpServerHttp::new(
+                server_name.to_string(),
+                format!("http://localhost:{tcp_port}"),
+            )),
         };
 
         // remember for later