Fix SSE tests failing on Linux

- Fix httplib::Client thread-safety issue: create clients in the same
  thread that uses them (Linux-specific behavior)
- Fix SSE server startup probe: track actual data receipt instead of
  checking Result object (cancelled requests appear as errors to httplib)

The root cause was that httplib::Client is not thread-safe when created
in one thread and used in another on Linux. Additionally, when an SSE
content receiver returns false to cancel, httplib reports the result as
an error even though data was successfully received.

Author: 0xeb

examples/streaming_demo.cpp

@@ -44,12 +44,15 @@ int main()
     std::atomic<bool> sse_connected{false};
     std::string session_id;
 
-    httplib::Client cli("127.0.0.1", port);
-    cli.set_connection_timeout(std::chrono::seconds(10));
-    cli.set_read_timeout(std::chrono::seconds(20));
+    // NOTE: httplib::Client must be created in the same thread that uses it on Linux
     std::thread sse_thread(
-        [&]()
+        [&, port]()
         {
+            // Create client inside thread - httplib::Client is not thread-safe across threads on Linux
+            httplib::Client cli("127.0.0.1", port);
+            cli.set_connection_timeout(std::chrono::seconds(10));
+            cli.set_read_timeout(std::chrono::seconds(20));
+
             auto receiver = [&](const char* data, size_t len)
             {
                 sse_connected = true;

src/server/sse_server.cpp

@@ -479,18 +479,22 @@ bool SseServerWrapper::start()
 
     // Wait for server to be ready by probing the SSE endpoint briefly.
     // This reduces flakiness in constrained environments.
+    // NOTE: When the content receiver returns false to cancel, httplib reports the
+    // Result as an error even though data was received. Track actual data receipt.
     for (int attempt = 0; attempt < 20; ++attempt)
     {
+        bool received_data = false;
         httplib::Client probe(host_.c_str(), port_);
         probe.set_connection_timeout(std::chrono::seconds(2));
         probe.set_read_timeout(std::chrono::seconds(2));
-        auto res = probe.Get(sse_path_.c_str(),
-                             [&](const char*, size_t)
-                             {
-                                 // Cancel after first chunk to indicate readiness
-                                 return false;
-                             });
-        if (res)
+        probe.Get(sse_path_.c_str(),
+                  [&](const char*, size_t)
+                  {
+                      // Cancel after first chunk to indicate readiness
+                      received_data = true;
+                      return false;
+                  });
+        if (received_data)
             break;
         std::this_thread::sleep_for(std::chrono::milliseconds(50));
     }

tests/server/sse.cpp

@@ -55,21 +55,22 @@ int main()
         return 1;
     }
 
-    // Create HTTP clients: one dedicated to SSE stream, one for POST requests
-    httplib::Client sse_client("127.0.0.1", port);
-    sse_client.set_read_timeout(std::chrono::seconds(20));
-    sse_client.set_connection_timeout(std::chrono::seconds(10));
-
     std::atomic<bool> sse_connected{false};
     std::atomic<int> events_received{0};
     Json received_event;
     std::mutex event_mutex;
     std::string session_id;
 
     // Start SSE connection in background thread (retry a few times for robustness)
+    // NOTE: httplib::Client must be created in the same thread that uses it on Linux
     std::thread sse_thread(
-        [&]()
+        [&, port]()
         {
+            // Create client inside thread - httplib::Client is not thread-safe across threads on Linux
+            httplib::Client sse_client("127.0.0.1", port);
+            sse_client.set_read_timeout(std::chrono::seconds(20));
+            sse_client.set_connection_timeout(std::chrono::seconds(10));
+
             // Give server a moment to fully initialize before first connection attempt
             std::this_thread::sleep_for(std::chrono::milliseconds(100));