Test that client-mode HTTP codec actually disables body_timeout (#212)

The state-machine test already proves body_timeout == 0 disables the
body timer. What it does not prove is that HttpCodecFilter in client
mode is actually wired to pass 0. The client-mode fix is a single
ternary in the filter's constructor; a regression (e.g. someone
reverting to a flat 60s) would bring back the SSE crash silently.

Add a narrow introspection accessor:
  - HttpCodecStateMachine::config() — read-only view of the
    as-configured values (immutable after construction).
  - HttpCodecFilter::bodyTimeout() — forwards to the state machine's
    configured body_timeout.

Use it in two new tests: server mode retains 60s, client mode is 0.

Author: gophergogo

include/mcp/filter/http_codec_filter.h

@@ -210,6 +210,18 @@ class HttpCodecFilter : public network::Filter {
    */
   void markSseGetSent() { sse_get_sent_ = true; }
 
+  /**
+   * Body timeout actually configured on the state machine. In client mode
+   * this is disabled (0) because SSE response streams may sit idle between
+   * server-pushed events; in server mode it is bounded. Exposed for
+   * introspection and for tests that guard against regressions in the
+   * client/server wiring.
+   */
+  std::chrono::milliseconds bodyTimeout() const {
+    return state_machine_ ? state_machine_->config().body_timeout
+                          : std::chrono::milliseconds(0);
+  }
+
  private:
   // Inner class implementing MessageEncoder
   class MessageEncoderImpl : public MessageEncoder {

include/mcp/filter/http_codec_state_machine.h

@@ -345,6 +345,12 @@ class HttpCodecStateMachine {
    */
   static std::string getEventName(HttpCodecEvent event);
 
+  /**
+   * Configured values (as passed into the constructor). Read-only; the
+   * config is immutable after construction.
+   */
+  const HttpCodecStateMachineConfig& config() const { return config_; }
+
  protected:
   // ===== Protected Methods for Extension =====
 

tests/filter/test_http_codec_filter.cc

@@ -548,6 +548,47 @@ TEST_F(HttpCodecFilterRealIoTest, StateMachineIntegration) {
   EXPECT_EQ(headers["url"], "/state-test");
 }
 
+// ---------------------------------------------------------------------------
+// Body-timeout wiring by role
+//
+// Regression guard for the SSE crash: in client mode the codec is expected
+// to disable the body timer (body_timeout == 0) because SSE response bodies
+// are an open-ended stream that may sit idle between server-pushed events.
+// In server mode the 60s body timeout must stay on — request bodies are
+// expected to complete promptly. These tests read back the value actually
+// stored on the state machine so a regression in the is_server_ ternary in
+// http_codec_filter.cc is caught directly.
+// ---------------------------------------------------------------------------
+
+class HttpCodecFilterBodyTimeoutTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    auto factory = event::createLibeventDispatcherFactory();
+    dispatcher_ = factory->createDispatcher("codec-bt");
+    // Run once so timers can be created (state machine arms from ctor).
+    dispatcher_->run(event::RunType::NonBlock);
+    callbacks_ = std::make_unique<TestRequestCallbacks>();
+  }
+
+  std::unique_ptr<event::Dispatcher> dispatcher_;
+  std::unique_ptr<TestRequestCallbacks> callbacks_;
+};
+
+TEST_F(HttpCodecFilterBodyTimeoutTest, ServerModeKeepsBodyTimeoutBounded) {
+  HttpCodecFilter filter(*callbacks_, *dispatcher_, /*is_server=*/true);
+  EXPECT_EQ(filter.bodyTimeout(), 60000ms)
+      << "server mode must retain a bounded body timeout so request bodies "
+         "that stall don't wedge a connection";
+}
+
+TEST_F(HttpCodecFilterBodyTimeoutTest, ClientModeDisablesBodyTimeout) {
+  HttpCodecFilter filter(*callbacks_, *dispatcher_, /*is_server=*/false);
+  EXPECT_EQ(filter.bodyTimeout(), 0ms)
+      << "client mode must disable the body timer — an SSE response body is "
+         "an open-ended stream and a bounded body timeout would fire during "
+         "normal idle gaps, then crash the state machine on a live stream";
+}
+
 }  // namespace
 }  // namespace filter
 }  // namespace mcp