Add HttpAsyncClient built on HttpCodecFilter (#213)

HttpAsyncClient hosts one outbound TCP connection per send(), installs
the existing HttpCodecFilter in client mode as a read-only filter, and
formats the request bytes directly so callers keep full control over
method, path, and headers. Each request context implements
DeferredDeletable; on completion the client hands ownership to
Dispatcher::deferredDelete so the connection, codec filter, and
callbacks tear down past the current callback frame rather than
unwinding from inside their own callbacks.

Body handling reflects a quirk of the codec in client mode: each body
chunk is emitted twice, once inline and once again with the
accumulated body at message-complete. The client takes only the
end_stream delivery so the response body matches what arrived on the
wire.

Author: gophergogo

CMakeLists.txt

@@ -489,6 +489,7 @@ set(MCP_CLIENT_SERVER_SOURCES
 set(MCP_HTTP_SOURCES
     src/http/http_parser.cc
     src/http/sse_parser.cc
+    src/http/http_async_client.cc           # Async HTTP/1.1 client built on codec filter
     src/transport/http_sse_transport_socket.cc  # HTTP+SSE with layered architecture
     src/transport/https_sse_transport_factory.cc  # HTTPS+SSE factory
 )

include/mcp/http/http_async_client.h

@@ -0,0 +1,94 @@
+#ifndef MCP_HTTP_HTTP_ASYNC_CLIENT_H
+#define MCP_HTTP_HTTP_ASYNC_CLIENT_H
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+
+#include "mcp/event/event_loop.h"
+#include "mcp/network/socket_interface.h"
+#include "mcp/network/transport_socket.h"
+
+namespace mcp {
+namespace http {
+
+// Request handed to HttpAsyncClient::send.
+// The url is a full absolute URL (scheme://host[:port]/path). host must be
+// a dotted-quad IPv4 literal — hostname resolution is not performed here
+// so that callers running on the dispatcher thread never block on DNS.
+struct HttpRequest {
+  std::string method{"POST"};
+  std::string url;
+  std::map<std::string, std::string> headers;
+  std::string body;
+};
+
+// Response delivered to the HttpResponseCallback on success.
+struct HttpResponse {
+  int status_code{0};
+  std::string status_text;
+  std::map<std::string, std::string> headers;
+  std::string body;
+};
+
+// Exactly one of these fires per send().
+using HttpResponseCallback = std::function<void(HttpResponse)>;
+using HttpErrorCallback = std::function<void(const std::string& error)>;
+
+/**
+ * HttpAsyncClient — minimal fire-and-forget HTTP/1.1 client.
+ *
+ * Each send() creates an isolated request context: its own client
+ * connection, its own HttpCodecFilter (client mode), and its own
+ * callbacks. Request contexts are owned by the client until they
+ * complete, then handed to Dispatcher::deferredDelete so teardown
+ * runs past the current callback frame (Envoy-style lifetime, which
+ * avoids destroying a connection from inside its own callback).
+ *
+ * All public methods must be invoked from the dispatcher thread —
+ * this matches the project-wide convention that mutating network
+ * objects off-thread is undefined.
+ */
+class HttpAsyncClient {
+ public:
+  HttpAsyncClient(
+      event::Dispatcher& dispatcher,
+      network::SocketInterface& socket_interface,
+      std::unique_ptr<network::TransportSocketFactoryBase> transport_factory);
+  ~HttpAsyncClient();
+
+  HttpAsyncClient(const HttpAsyncClient&) = delete;
+  HttpAsyncClient& operator=(const HttpAsyncClient&) = delete;
+
+  /**
+   * Send an HTTP request. Exactly one of on_response or on_error will
+   * be invoked (on the dispatcher thread) before the request context
+   * is torn down. Returns false if the URL could not be parsed; in
+   * that case no callback fires.
+   */
+  bool send(const HttpRequest& request,
+            HttpResponseCallback on_response,
+            HttpErrorCallback on_error);
+
+ private:
+  class RequestContext;
+
+  // Called by RequestContext when it completes (success or failure).
+  // Extracts the unique_ptr from active_requests_ and hands it to
+  // Dispatcher::deferredDelete so the connection and filter tear down
+  // after the current callback returns.
+  void finishRequest(RequestContext* ctx);
+
+  event::Dispatcher& dispatcher_;
+  network::SocketInterface& socket_interface_;
+  std::unique_ptr<network::TransportSocketFactoryBase> transport_factory_;
+  std::map<RequestContext*, std::unique_ptr<RequestContext>> active_requests_;
+};
+
+using HttpAsyncClientPtr = std::unique_ptr<HttpAsyncClient>;
+
+}  // namespace http
+}  // namespace mcp
+
+#endif  // MCP_HTTP_HTTP_ASYNC_CLIENT_H