Merge pull request #120 from lsytj0413/replace-fxhash-by-rustc_hash

opt: replace unmaintained fxhash by rustc_hash crate

Author: nikomatsakis

Cargo.toml

@@ -53,7 +53,7 @@ hyper = "1.0"
 boxfnonce = "0.1.1"
 chrono = "0.4"
 futures = "0.3.31"
-fxhash = "0.2.1"
+rustc-hash = "2.1.1"
 jsonrpcmsg = "0.1.2"
 
 # Testing

src/sacp-conductor/Cargo.toml

@@ -40,7 +40,7 @@ tracing-appender.workspace = true
 tracing-subscriber.workspace = true
 uuid.workspace = true
 async-stream = "0.3.6"
-fxhash.workspace = true
+rustc-hash.workspace = true
 futures-concurrency = "7.6.3"
 
 [dev-dependencies]

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

@@ -8,7 +8,7 @@ use axum::{
 use futures::{SinkExt, StreamExt as _, channel::mpsc, future::Either, stream::Stream};
 use futures_concurrency::future::FutureExt as _;
 use futures_concurrency::stream::StreamExt as _;
-use fxhash::FxHashMap;
+use rustc_hash::FxHashMap;
 use sacp::{BoxFuture, Channel, ConnectTo, jsonrpcmsg::Message, role::mcp};
 use std::{collections::VecDeque, pin::pin, sync::Arc};
 use tokio::net::TcpListener;

src/sacp-conductor/src/trace.rs

@@ -8,9 +8,9 @@ use std::io::{BufWriter, Write};
 use std::path::Path;
 use std::time::Instant;
 
-use fxhash::FxHashMap;
+use rustc_hash::FxHashMap;
 use sacp::schema::{McpOverAcpMessage, SuccessorMessage};
-use sacp::{jsonrpcmsg, DynConnectTo, JsonRpcMessage, Role, UntypedMessage};
+use sacp::{DynConnectTo, JsonRpcMessage, Role, UntypedMessage, jsonrpcmsg};
 use serde::{Deserialize, Serialize};
 
 use crate::ComponentIndex;

src/sacp/Cargo.toml

@@ -15,7 +15,7 @@ anyhow.workspace = true
 boxfnonce.workspace = true
 futures.workspace = true
 futures-concurrency = "7.6.3"
-fxhash.workspace = true
+rustc-hash.workspace = true
 jsonrpcmsg.workspace = true
 rmcp = { workspace = true, features = ["server"] }
 schemars.workspace = true

src/sacp/src/jsonrpc/incoming_actor.rs

@@ -5,7 +5,7 @@ use futures::StreamExt as _;
 use futures::channel::mpsc;
 use futures::channel::oneshot;
 use futures_concurrency::stream::StreamExt as _;
-use fxhash::FxHashMap;
+use rustc_hash::FxHashMap;
 use uuid::Uuid;
 
 use crate::Dispatch;
@@ -150,8 +150,7 @@ pub(super) async fn incoming_protocol_actor<Counterpart: Role>(
                             let id_json = serde_json::to_value(&id).unwrap();
                             if let Some(pending_reply) = pending_replies.remove(&id_json) {
                                 // Route the response through the handler chain
-                                let dispatch =
-                                    dispatch_from_response(id, pending_reply, result);
+                                let dispatch = dispatch_from_response(id, pending_reply, result);
                                 dispatch_dispatch(
                                     counterpart.clone(),
                                     connection,

src/sacp/src/mcp_server/active_session.rs

@@ -1,6 +1,6 @@
 use futures::channel::mpsc;
 use futures::{SinkExt, StreamExt};
-use fxhash::FxHashMap;
+use rustc_hash::FxHashMap;
 
 use crate::mcp_server::{McpConnectionTo, McpServerConnect};
 use crate::role;
@@ -10,8 +10,8 @@ use crate::schema::{
 };
 use crate::util::MatchDispatchFrom;
 use crate::{
-    Agent, Channel, ConnectionTo, HandleDispatchFrom, Handled, Dispatch, Responder, Role, ConnectTo,
-    UntypedMessage,
+    Agent, Channel, ConnectTo, ConnectionTo, Dispatch, HandleDispatchFrom, Handled, Responder,
+    Role, UntypedMessage,
 };
 use std::sync::Arc;
 
@@ -72,7 +72,8 @@ where
             let connection_id = connection_id.clone();
             let acp_connection = acp_connection.clone();
 
-            role::mcp::Client.builder()
+            role::mcp::Client
+                .builder()
                 .on_receive_dispatch(
                     async move |message: Dispatch, _mcp_connection| {
                         // Wrap the message in McpOverAcp{Request,Notification} and forward to successor

src/sacp/src/mcp_server/builder.rs

@@ -8,7 +8,7 @@ use futures::{
     future::{BoxFuture, Either},
 };
 use futures_concurrency::future::TryJoin;
-use fxhash::FxHashMap;
+use rustc_hash::FxHashMap;
 
 /// Tracks which tools are enabled.
 ///
@@ -48,7 +48,7 @@ use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
 
 use super::{McpConnectionTo, McpTool};
 use crate::{
-    ByteStreams, DynConnectTo, ConnectTo,
+    ByteStreams, ConnectTo, DynConnectTo,
     jsonrpc::run::{ChainRun, NullRun, RunWithConnectionTo},
     mcp_server::{
         McpServer, McpServerConnect,
@@ -350,7 +350,10 @@ impl<'scope, Counterpart: Role> McpServerConnect<Counterpart> for McpServerBuilt
         self.name.clone()
     }
 
-    fn connect(&self, mcp_connection: McpConnectionTo<Counterpart>) -> DynConnectTo<role::mcp::Client> {
+    fn connect(
+        &self,
+        mcp_connection: McpConnectionTo<Counterpart>,
+    ) -> DynConnectTo<role::mcp::Client> {
         DynConnectTo::new(McpServerConnection {
             data: self.data.clone(),
             mcp_connection,
@@ -365,7 +368,10 @@ pub(crate) struct McpServerConnection<Counterpart: Role> {
 }
 
 impl<Counterpart: Role> ConnectTo<role::mcp::Client> for McpServerConnection<Counterpart> {
-    async fn connect_to(self, client: impl ConnectTo<role::mcp::Server>) -> Result<(), crate::Error> {
+    async fn connect_to(
+        self,
+        client: impl ConnectTo<role::mcp::Server>,
+    ) -> Result<(), crate::Error> {
         // Create tokio byte streams that rmcp expects
         let (mcp_server_stream, mcp_client_stream) = tokio::io::duplex(8192);
         let (mcp_server_read, mcp_server_write) = tokio::io::split(mcp_server_stream);
@@ -375,8 +381,11 @@ impl<Counterpart: Role> ConnectTo<role::mcp::Client> for McpServerConnection<Cou
             // Connect byte_streams to the provided client
             let byte_streams =
                 ByteStreams::new(mcp_client_write.compat_write(), mcp_client_read.compat());
-            let _ =
-                <ByteStreams<_, _> as ConnectTo<role::mcp::Client>>::connect_to(byte_streams, client).await;
+            let _ = <ByteStreams<_, _> as ConnectTo<role::mcp::Client>>::connect_to(
+                byte_streams,
+                client,
+            )
+            .await;
             Ok(())
         };
 
@@ -427,7 +436,9 @@ impl<R: Role> ServerHandler for McpServerConnection<R> {
         // Execute the user's tool, unless cancellation occurs
         let has_structured_output = registered.has_structured_output;
         match futures::future::select(
-            registered.tool.call_tool(serde_value, self.mcp_connection.clone()),
+            registered
+                .tool
+                .call_tool(serde_value, self.mcp_connection.clone()),
             pin!(context.ct.cancelled()),
         )
         .await
@@ -572,7 +583,11 @@ where
         self.description.clone()
     }
 
-    async fn call_tool(&self, params: P, mcp_connection: McpConnectionTo<R>) -> Result<Ret, crate::Error> {
+    async fn call_tool(
+        &self,
+        params: P,
+        mcp_connection: McpConnectionTo<R>,
+    ) -> Result<Ret, crate::Error> {
         let (result_tx, result_rx) = oneshot::channel();
 
         self.call_tx