Step 2: Extract MCP bridging into agent-client-protocol-polyfill crate

New crate src/agent-client-protocol-polyfill with mcp_over_acp module:
- McpOverAcpPolyfill proxy (ConnectTo<Conductor>)
- BridgeConnectionActor, BridgeListeners, BridgeConnection
- HTTP and stdio bridge transports
- Uses own BridgeMessage enum instead of ConductorMessage

Conductor bridge code still present (removed in Step 3).

Author: nikomatsakis

Cargo.lock

@@ -4,6 +4,7 @@ members = [
     "src/agent-client-protocol-conductor",
     "src/agent-client-protocol-cookbook",
     "src/agent-client-protocol-derive",
+    "src/agent-client-protocol-polyfill",
     "src/agent-client-protocol-rmcp",
     "src/agent-client-protocol-test",
     "src/agent-client-protocol-trace-viewer",

Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "agent-client-protocol-polyfill"
+version = "0.11.1"
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description = "Polyfill proxies for Agent Client Protocol backward compatibility"
+keywords = ["acp", "agent", "mcp", "polyfill"]
+categories = ["development-tools"]
+
+[dependencies]
+agent-client-protocol.workspace = true
+agent-client-protocol-schema.workspace = true
+anyhow.workspace = true
+async-stream.workspace = true
+axum.workspace = true
+futures.workspace = true
+futures-concurrency.workspace = true
+rustc-hash.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+thiserror = "2.0"
+tokio.workspace = true
+tokio-util.workspace = true
+tracing.workspace = true
+uuid.workspace = true
+
+[lints]
+workspace = true

src/agent-client-protocol-polyfill/Cargo.toml

@@ -0,0 +1,13 @@
+//! # agent-client-protocol-polyfill
+//!
+//! Polyfill proxies for backward compatibility with agents that don't support
+//! newer ACP features natively.
+//!
+//! ## MCP-over-ACP Polyfill
+//!
+//! The [`mcp_over_acp`] module provides a proxy that bridges MCP-over-ACP transport
+//! for agents that don't support `mcpCapabilities.acp`. It intercepts `NewSessionRequest`
+//! to transform `McpServer::Http` entries with `acp:` URLs into localhost TCP bridges,
+//! and handles `_mcp/*` messages by routing them through those bridges.
+
+pub mod mcp_over_acp;

src/agent-client-protocol-polyfill/src/lib.rs

@@ -0,0 +1,80 @@
+use agent_client_protocol::{
+    ConnectTo, Dispatch, DynConnectTo, role::mcp, schema::McpDisconnectNotification,
+};
+use futures::{SinkExt as _, StreamExt as _, channel::mpsc};
+use tracing::info;
+
+use super::BridgeMessage;
+
+/// Actor that bridges a single MCP connection between a local MCP client
+/// and the ACP proxy chain.
+#[derive(Debug)]
+pub(crate) struct BridgeConnectionActor {
+    transport: DynConnectTo<mcp::Client>,
+    bridge_tx: mpsc::Sender<BridgeMessage>,
+    to_mcp_client_rx: mpsc::Receiver<Dispatch>,
+}
+
+impl BridgeConnectionActor {
+    pub fn new(
+        component: impl ConnectTo<mcp::Client>,
+        bridge_tx: mpsc::Sender<BridgeMessage>,
+        to_mcp_client_rx: mpsc::Receiver<Dispatch>,
+    ) -> Self {
+        Self {
+            transport: DynConnectTo::new(component),
+            bridge_tx,
+            to_mcp_client_rx,
+        }
+    }
+
+    pub async fn run(self, connection_id: String) -> Result<(), agent_client_protocol::Error> {
+        info!(connection_id, "MCP bridge connected");
+
+        let Self {
+            transport,
+            mut bridge_tx,
+            to_mcp_client_rx,
+        } = self;
+
+        let result = mcp::Client
+            .builder()
+            .name(format!("mcp-client-to-polyfill({connection_id})"))
+            .on_receive_dispatch(
+                {
+                    let mut bridge_tx = bridge_tx.clone();
+                    let connection_id = connection_id.clone();
+                    async move |message: Dispatch, _cx| {
+                        bridge_tx
+                            .send(BridgeMessage::ClientToServer {
+                                connection_id: connection_id.clone(),
+                                message,
+                            })
+                            .await
+                            .map_err(|_| agent_client_protocol::Error::internal_error())
+                    }
+                },
+                agent_client_protocol::on_receive_dispatch!(),
+            )
+            .connect_with(transport, async move |mcp_connection_to_client| {
+                let mut to_mcp_client_rx = to_mcp_client_rx;
+                while let Some(message) = to_mcp_client_rx.next().await {
+                    mcp_connection_to_client.send_proxied_message(message)?;
+                }
+                Ok(())
+            })
+            .await;
+
+        bridge_tx
+            .send(BridgeMessage::Disconnected {
+                notification: McpDisconnectNotification {
+                    connection_id,
+                    meta: None,
+                },
+            })
+            .await
+            .map_err(|_| agent_client_protocol::Error::internal_error())?;
+
+        result
+    }
+}