diff --git a/.azure/default-build.yml b/.azure/default-build.yml
index c7c29a64..49e31559 100644
--- a/.azure/default-build.yml
+++ b/.azure/default-build.yml
@@ -7,13 +7,14 @@ parameters:
   timeoutInMinutes: 60
   cMakeRunArgs: ''
   configuration: 'Release'
+  useCppRestSDK: true
   gtestFlags: '--gtest_output=xml:$(Build.ArtifactStagingDirectory)/testOut/'
 
 jobs:
 - template: /eng/common/templates/job/job.yml
   parameters:
     name: ${{ coalesce(parameters.jobName, parameters.agentOs) }}
-    displayName: ${{ coalesce(parameters.jobDisplayName, parameters.agentOs) }}
+    displayName: ${{ coalesce(parameters.jobName, parameters.agentOs) }}
     dependsOn: ${{ parameters.dependsOn }}
     timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
     ${{ if and(eq(variables['System.TeamProject'], 'internal'), eq(parameters.agentOs, 'Windows')) }}:
@@ -38,12 +39,13 @@ jobs:
         path: ./submodules/vcpkg/installed
         cacheHitVar: CACHE_RESTORED
       displayName: Cache vcpkg packages
+      condition: eq( '${{ parameters.useCppRestSDK }}', 'true' )
   
     - ${{ parameters.beforeBuild }}
   
     - task: CMake@1
       inputs:
-        cmakeArgs: .. ${{ parameters.cMakeRunArgs }} -DCMAKE_TOOLCHAIN_FILE=../submodules/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_BUILD_TYPE=${{ parameters.configuration }} -DUSE_CPPRESTSDK=true
+        cmakeArgs: .. ${{ parameters.cMakeRunArgs }} -DCMAKE_TOOLCHAIN_FILE=../submodules/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_BUILD_TYPE=${{ parameters.configuration }} -DUSE_CPPRESTSDK=${{ parameters.useCppRestSDK }}
         workingDirectory: 'build.${{ parameters.configuration }}'
       displayName: Create build files
     - task: CMake@1
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 776b2f25..33ff7340 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,14 +32,16 @@ include_directories (include)
 # We need this for testing, but we might just add all the files to the test project manually
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
-if(NOT WIN32)
-  if(APPLE)
-    file(GLOB OPENSSL_ROOT_DIR /usr/local/Cellar/openssl/*)
-    list(REVERSE OPENSSL_ROOT_DIR)
+if(USE_CPPRESTSDK)
+  if(NOT WIN32)
+    if(APPLE)
+      file(GLOB OPENSSL_ROOT_DIR /usr/local/Cellar/openssl/*)
+      list(REVERSE OPENSSL_ROOT_DIR)
+    endif()
+
+    find_package(OpenSSL 1.0.0 REQUIRED)
+    find_package(Boost REQUIRED COMPONENTS system thread chrono)
   endif()
-
-  find_package(OpenSSL 1.0.0 REQUIRED)
-  find_package(Boost REQUIRED COMPONENTS system thread chrono)
 endif()
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 53bff5f1..ebb670a4 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -30,7 +30,8 @@ stages:
   - template: .azure/default-build.yml
     parameters:
       agentOs: Windows
-      jobName: Windows_Build_Test
+      jobName: Windows_Build_Test_With_CppRestSDK
+      useCppRestSDK: true
       cMakeRunArgs: '-A x64'
       beforeBuild:
       # check if vcpkg exists on the machine before trying to build it
@@ -57,12 +58,15 @@ stages:
   - template: .azure/default-build.yml
     parameters:
       agentOs: macOs
-      jobName: Mac_Build_Test
+      jobName: Mac_Build_Test_With_CppRestSDK
+      useCppRestSDK: true
       beforeBuild:
       # XCode 11 doesn't play nicely with gcc, workaround by using XCode 10. We can try updating to a newer XCode in the future
       # Once the problem has been resolved
       - script: sudo xcode-select --switch /Applications/Xcode_10.3.app
+        displayName: xcode-select
       - script: brew install gcc
+        displayName: Install gcc
       - bash: "./submodules/vcpkg/bootstrap-vcpkg.sh"
         condition: ne(variables.CACHE_RESTORED, 'true')
         displayName: Bootstrap vcpkg
@@ -73,17 +77,47 @@ stages:
   - template: .azure/default-build.yml
     parameters:
       agentOs: Linux
-      jobName: Linux_Build_Test
+      jobName: Linux_Build_Test_With_CppRestSDK
+      useCppRestSDK: true
       beforeBuild:
       - script: sudo vcpkg install cpprestsdk boost-system boost-chrono boost-thread --vcpkg-root ./submodules/vcpkg
         condition: ne(variables.CACHE_RESTORED, 'true')
         displayName: vcpkg install dependencies
 
+  - template: .azure/default-build.yml
+    parameters:
+      agentOs: Linux
+      jobName: Linux_Build_Test
+      useCppRestSDK: false
+
+  - template: .azure/default-build.yml
+    parameters:
+      agentOs: Windows
+      jobName: Windows_Build_Test
+      useCppRestSDK: false
+      cMakeRunArgs: '-A x64'
+
+  - template: .azure/default-build.yml
+    parameters:
+      agentOs: macOs
+      jobName: Mac_Build_Test
+      useCppRestSDK: false
+      beforeBuild:
+      # XCode 11 doesn't play nicely with gcc, workaround by using XCode 10. We can try updating to a newer XCode in the future
+      # Once the problem has been resolved
+      - script: sudo xcode-select --switch /Applications/Xcode_10.3.app
+        displayName: xcode-select
+      - script: brew install gcc
+        displayName: Install gcc
+
   # Publish to the BAR
   - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
     - template: /eng/common/templates/job/publish-build-assets.yml
       parameters:
         dependsOn:
+          - Windows_Build_Test_With_CppRestSDK
+          - Mac_Build_Test_With_CppRestSDK
+          - Linux_Build_Test_With_CppRestSDK
           - Windows_Build_Test
           - Mac_Build_Test
           - Linux_Build_Test
diff --git a/include/signalrclient/_exports.h b/include/signalrclient/_exports.h
index c9e9fadb..79a5fa0d 100644
--- a/include/signalrclient/_exports.h
+++ b/include/signalrclient/_exports.h
@@ -11,4 +11,14 @@
 #else
 #define SIGNALRCLIENT_API __declspec(dllimport)
 #endif // SIGNALRCLIENT_EXPORTS
-#endif // NO_SIGNALRCLIENT_EXPORTS
\ No newline at end of file
+#endif // NO_SIGNALRCLIENT_EXPORTS
+
+#ifndef _WIN32
+#ifndef __cdecl
+#ifdef cdecl
+#define __cdecl __attribute__((cdecl))
+#else
+#define __cdecl
+#endif // cdecl
+#endif // !__cdecl
+#endif // _WIN32
\ No newline at end of file
diff --git a/include/signalrclient/hub_connection.h b/include/signalrclient/hub_connection.h
index 9eef359e..8cbebc59 100644
--- a/include/signalrclient/hub_connection.h
+++ b/include/signalrclient/hub_connection.h
@@ -55,7 +55,7 @@ namespace signalr
 
         explicit hub_connection(const std::string& url, trace_level trace_level = trace_level::all,
             std::shared_ptr<log_writer> log_writer = nullptr, std::shared_ptr<http_client> http_client = nullptr,
-            std::function<std::shared_ptr<websocket_client>()> websocket_factory = nullptr);
+            std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory = nullptr);
 
         std::shared_ptr<hub_connection_impl> m_pImpl;
     };
diff --git a/include/signalrclient/hub_connection_builder.h b/include/signalrclient/hub_connection_builder.h
index 956b2f1b..258ff530 100644
--- a/include/signalrclient/hub_connection_builder.h
+++ b/include/signalrclient/hub_connection_builder.h
@@ -28,7 +28,7 @@ namespace signalr
 
         SIGNALRCLIENT_API hub_connection_builder& with_logging(std::shared_ptr<log_writer> logger, trace_level logLevel);
 
-        SIGNALRCLIENT_API hub_connection_builder& with_websocket_factory(std::function<std::shared_ptr<websocket_client>()> factory);
+        SIGNALRCLIENT_API hub_connection_builder& with_websocket_factory(std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> factory);
 
         SIGNALRCLIENT_API hub_connection_builder& with_http_client(std::shared_ptr<http_client> http_client);
 
@@ -39,7 +39,7 @@ namespace signalr
         std::string m_url;
         std::shared_ptr<log_writer> m_logger;
         trace_level m_log_level;
-        std::function<std::shared_ptr<websocket_client>()> m_websocket_factory;
+        std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> m_websocket_factory;
         std::shared_ptr<http_client> m_http_client;
     };
 }
diff --git a/include/signalrclient/signalr_client_config.h b/include/signalrclient/signalr_client_config.h
index 428e71fa..ccc3f2ff 100644
--- a/include/signalrclient/signalr_client_config.h
+++ b/include/signalrclient/signalr_client_config.h
@@ -9,13 +9,15 @@
 #endif
 
 #include "_exports.h"
+#include <map>
+#include <string>
 
 namespace signalr
 {
     class signalr_client_config
     {
-#ifdef USE_CPPRESTSDK
     public:
+#ifdef USE_CPPRESTSDK
         SIGNALRCLIENT_API void __cdecl set_proxy(const web::web_proxy &proxy);
         // Please note that setting credentials does not work in all cases.
         // For example, Basic Authentication fails under Win32.
@@ -28,14 +30,17 @@ namespace signalr
 
         SIGNALRCLIENT_API web::websockets::client::websocket_client_config __cdecl get_websocket_client_config() const noexcept;
         SIGNALRCLIENT_API void __cdecl set_websocket_client_config(const web::websockets::client::websocket_client_config& websocket_client_config);
+#endif
 
-        SIGNALRCLIENT_API web::http::http_headers __cdecl get_http_headers() const noexcept;
-        SIGNALRCLIENT_API void __cdecl set_http_headers(const web::http::http_headers& http_headers);
+        SIGNALRCLIENT_API const std::map<std::string, std::string>& __cdecl get_http_headers() const noexcept;
+        SIGNALRCLIENT_API std::map<std::string, std::string>& __cdecl get_http_headers() noexcept;
+        SIGNALRCLIENT_API void __cdecl set_http_headers(const std::map<std::string, std::string>& http_headers);
 
     private:
+#ifdef USE_CPPRESTSDK
         web::http::client::http_client_config m_http_client_config;
         web::websockets::client::websocket_client_config m_websocket_client_config;
-        web::http::http_headers m_http_headers;
 #endif
+        std::map<std::string, std::string> m_http_headers;
     };
 }
diff --git a/src/signalrclient/connection_impl.cpp b/src/signalrclient/connection_impl.cpp
index 3d7f4a41..df1986d8 100644
--- a/src/signalrclient/connection_impl.cpp
+++ b/src/signalrclient/connection_impl.cpp
@@ -33,7 +33,7 @@ namespace signalr
     }
 
     std::shared_ptr<connection_impl> connection_impl::create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
-        std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory)
     {
         return std::shared_ptr<connection_impl>(new connection_impl(url, trace_level,
             log_writer ? log_writer : std::make_shared<trace_log_writer>(), http_client, websocket_factory));
@@ -50,12 +50,14 @@ namespace signalr
         }
         else
         {
+#ifdef USE_CPPRESTSDK
             m_http_client = std::unique_ptr<class http_client>(new default_http_client());
+#endif
         }
     }
 
     connection_impl::connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
-        std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory)
         : m_base_url(url), m_connection_state(connection_state::disconnected), m_logger(log_writer, trace_level), m_transport(nullptr),
         m_message_received([](const std::string&) noexcept {}), m_disconnected([]() noexcept {})
     {
@@ -73,7 +75,7 @@ namespace signalr
         if (websocket_factory == nullptr)
         {
 #ifdef USE_CPPRESTSDK
-            websocket_factory = []() { return std::make_shared<default_websocket_client>(); };
+            websocket_factory = [](const signalr_client_config& signalr_client_config) { return std::make_shared<default_websocket_client>(signalr_client_config); };
 #endif
         }
 
@@ -198,9 +200,8 @@ namespace signalr
                 {
                     if (!response.accessToken.empty())
                     {
-                        auto headers = connection->m_signalr_client_config.get_http_headers();
-                        headers[_XPLATSTR("Authorization")] = utility::conversions::to_string_t("Bearer " + response.accessToken);
-                        connection->m_signalr_client_config.set_http_headers(headers);
+                        auto& headers = connection->m_signalr_client_config.get_http_headers();
+                        headers["Authorization"] = "Bearer " + response.accessToken;
                     }
                     connection->start_negotiate(response.url, redirect_count + 1, callback);
                     return;
diff --git a/src/signalrclient/connection_impl.h b/src/signalrclient/connection_impl.h
index e1e72a56..900024f3 100644
--- a/src/signalrclient/connection_impl.h
+++ b/src/signalrclient/connection_impl.h
@@ -29,7 +29,7 @@ namespace signalr
         static std::shared_ptr<connection_impl> create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer);
 
         static std::shared_ptr<connection_impl> create(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
-            std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory);
+            std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory);
 
         connection_impl(const connection_impl&) = delete;
 
@@ -70,7 +70,7 @@ namespace signalr
             std::unique_ptr<http_client> http_client, std::unique_ptr<transport_factory> transport_factory);
 
         connection_impl(const std::string& url, trace_level trace_level, const std::shared_ptr<log_writer>& log_writer,
-            std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory);
+            std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory);
 
         void start_transport(const std::string& url, std::function<void(std::shared_ptr<transport>, std::exception_ptr)> callback);
         void send_connect_request(const std::shared_ptr<transport>& transport,
diff --git a/src/signalrclient/default_websocket_client.cpp b/src/signalrclient/default_websocket_client.cpp
index e9a2fc3e..fe50996c 100644
--- a/src/signalrclient/default_websocket_client.cpp
+++ b/src/signalrclient/default_websocket_client.cpp
@@ -13,7 +13,11 @@ namespace signalr
         static web::websockets::client::websocket_client_config create_client_config(const signalr_client_config& signalr_client_config) noexcept
         {
             auto websocket_client_config = signalr_client_config.get_websocket_client_config();
-            websocket_client_config.headers() = signalr_client_config.get_http_headers();
+            auto& websocket_headers = websocket_client_config.headers();
+            for (auto& header : signalr_client_config.get_http_headers())
+            {
+                websocket_headers.add(utility::conversions::to_string_t(header.first), utility::conversions::to_string_t(header.second));
+            }
 
             return websocket_client_config;
         }
diff --git a/src/signalrclient/hub_connection.cpp b/src/signalrclient/hub_connection.cpp
index 1ae1a2d4..1e73b521 100644
--- a/src/signalrclient/hub_connection.cpp
+++ b/src/signalrclient/hub_connection.cpp
@@ -12,7 +12,7 @@ namespace signalr
 {
     hub_connection::hub_connection(const std::string& url,
         trace_level trace_level, std::shared_ptr<log_writer> log_writer, std::shared_ptr<http_client> http_client,
-        std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory)
         : m_pImpl(hub_connection_impl::create(url, trace_level, log_writer, http_client, websocket_factory))
     {}
 
diff --git a/src/signalrclient/hub_connection_builder.cpp b/src/signalrclient/hub_connection_builder.cpp
index 582de5e1..4be9a102 100644
--- a/src/signalrclient/hub_connection_builder.cpp
+++ b/src/signalrclient/hub_connection_builder.cpp
@@ -3,6 +3,7 @@
 
 #include "stdafx.h"
 #include "signalrclient/hub_connection_builder.h"
+#include <stdexcept>
 
 namespace signalr
 {
@@ -55,7 +56,7 @@ namespace signalr
         return *this;
     }
 
-    hub_connection_builder& hub_connection_builder::with_websocket_factory(std::function<std::shared_ptr<websocket_client>()> factory)
+    hub_connection_builder& hub_connection_builder::with_websocket_factory(std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> factory)
     {
         m_websocket_factory = factory;
 
diff --git a/src/signalrclient/hub_connection_impl.cpp b/src/signalrclient/hub_connection_impl.cpp
index 8e9b05a0..685a70ee 100644
--- a/src/signalrclient/hub_connection_impl.cpp
+++ b/src/signalrclient/hub_connection_impl.cpp
@@ -24,7 +24,7 @@ namespace signalr
 
     std::shared_ptr<hub_connection_impl> hub_connection_impl::create(const std::string& url, trace_level trace_level,
         const std::shared_ptr<log_writer>& log_writer, std::shared_ptr<http_client> http_client,
-        std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory)
     {
         auto connection = std::shared_ptr<hub_connection_impl>(new hub_connection_impl(url, trace_level, log_writer, http_client, websocket_factory));
 
@@ -35,7 +35,7 @@ namespace signalr
 
     hub_connection_impl::hub_connection_impl(const std::string& url, trace_level trace_level,
         const std::shared_ptr<log_writer>& log_writer, std::shared_ptr<http_client> http_client,
-        std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+        std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory)
         : m_connection(connection_impl::create(url, trace_level, log_writer,
             http_client, websocket_factory)), m_logger(log_writer, trace_level),
         m_callback_manager(signalr::value(std::map<std::string, signalr::value> { { std::string("error"), std::string("connection went out of scope before invocation result was received") } })),
diff --git a/src/signalrclient/hub_connection_impl.h b/src/signalrclient/hub_connection_impl.h
index 5af3f438..644a2bc1 100644
--- a/src/signalrclient/hub_connection_impl.h
+++ b/src/signalrclient/hub_connection_impl.h
@@ -25,7 +25,7 @@ namespace signalr
     public:
         static std::shared_ptr<hub_connection_impl> create(const std::string& url, trace_level trace_level,
             const std::shared_ptr<log_writer>& log_writer, std::shared_ptr<http_client> http_client,
-            std::function<std::shared_ptr<websocket_client>()> websocket_factory);
+            std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory);
 
         hub_connection_impl(const hub_connection_impl&) = delete;
         hub_connection_impl& operator=(const hub_connection_impl&) = delete;
@@ -47,7 +47,7 @@ namespace signalr
     private:
         hub_connection_impl(const std::string& url, trace_level trace_level,
             const std::shared_ptr<log_writer>& log_writer, std::shared_ptr<http_client> http_client,
-            std::function<std::shared_ptr<websocket_client>()> websocket_factory);
+            std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory);
 
         std::shared_ptr<connection_impl> m_connection;
         logger m_logger;
diff --git a/src/signalrclient/negotiate.cpp b/src/signalrclient/negotiate.cpp
index 8ee8f6a8..7eab07b6 100644
--- a/src/signalrclient/negotiate.cpp
+++ b/src/signalrclient/negotiate.cpp
@@ -32,11 +32,7 @@ namespace signalr
             // TODO: signalr_client_config
             http_request request;
             request.method = http_method::POST;
-
-            for (auto& header : config.get_http_headers())
-            {
-                request.headers.insert(std::make_pair(utility::conversions::to_utf8string(header.first), utility::conversions::to_utf8string(header.second)));
-            }
+            request.headers = config.get_http_headers();
 
             client.send(negotiate_url, request, [callback](const http_response& http_response, std::exception_ptr exception)
             {
diff --git a/src/signalrclient/negotiation_response.h b/src/signalrclient/negotiation_response.h
index d727f390..de68db09 100644
--- a/src/signalrclient/negotiation_response.h
+++ b/src/signalrclient/negotiation_response.h
@@ -3,6 +3,9 @@
 
 #pragma once
 
+#include <vector>
+#include <string>
+
 namespace signalr
 {
     struct available_transport
diff --git a/src/signalrclient/signalr_client_config.cpp b/src/signalrclient/signalr_client_config.cpp
index 161af510..bd4d25ea 100644
--- a/src/signalrclient/signalr_client_config.cpp
+++ b/src/signalrclient/signalr_client_config.cpp
@@ -42,15 +42,20 @@ namespace signalr
     {
         m_websocket_client_config = websocket_client_config;
     }
+#endif
+
+    const std::map<std::string, std::string>& signalr_client_config::get_http_headers() const noexcept
+    {
+        return m_http_headers;
+    }
 
-    web::http::http_headers signalr_client_config::get_http_headers() const noexcept
+    std::map<std::string, std::string>& signalr_client_config::get_http_headers() noexcept
     {
         return m_http_headers;
     }
 
-    void signalr_client_config::set_http_headers(const web::http::http_headers& http_headers)
+    void signalr_client_config::set_http_headers(const std::map<std::string, std::string>& http_headers)
     {
         m_http_headers = http_headers;
     }
-#endif
 }
diff --git a/src/signalrclient/transport_factory.cpp b/src/signalrclient/transport_factory.cpp
index e18dfaf7..2bb1180b 100644
--- a/src/signalrclient/transport_factory.cpp
+++ b/src/signalrclient/transport_factory.cpp
@@ -9,17 +9,16 @@
 
 namespace signalr
 {
-    transport_factory::transport_factory(std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory)
+    transport_factory::transport_factory(std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory)
         : m_http_client(http_client), m_websocket_factory(websocket_factory)
     {}
 
     std::shared_ptr<transport> transport_factory::create_transport(transport_type transport_type, const logger& logger,
         const signalr_client_config& signalr_client_config)
     {
-        // TODO: Handle config with transport(s)
         if (transport_type == signalr::transport_type::websockets)
         {
-            return websocket_transport::create(m_websocket_factory,
+            return websocket_transport::create(m_websocket_factory, signalr_client_config,
                 logger);
         }
 
diff --git a/src/signalrclient/transport_factory.h b/src/signalrclient/transport_factory.h
index 17644a29..230a9037 100644
--- a/src/signalrclient/transport_factory.h
+++ b/src/signalrclient/transport_factory.h
@@ -16,7 +16,7 @@ namespace signalr
     class transport_factory
     {
     public:
-        transport_factory(std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>()> websocket_factory);
+        transport_factory(std::shared_ptr<http_client> http_client, std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> websocket_factory);
 
         virtual std::shared_ptr<transport> create_transport(transport_type transport_type, const logger& logger,
             const signalr_client_config& signalr_client_config);
@@ -24,6 +24,6 @@ namespace signalr
         virtual ~transport_factory();
     private:
         std::shared_ptr<http_client> m_http_client;
-        std::function<std::shared_ptr<websocket_client>()> m_websocket_factory;
+        std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> m_websocket_factory;
     };
 }
diff --git a/src/signalrclient/websocket_transport.cpp b/src/signalrclient/websocket_transport.cpp
index 3cc55376..fcbf025f 100644
--- a/src/signalrclient/websocket_transport.cpp
+++ b/src/signalrclient/websocket_transport.cpp
@@ -10,17 +10,18 @@
 
 namespace signalr
 {
-    std::shared_ptr<transport> websocket_transport::create(const std::function<std::shared_ptr<websocket_client>()>& websocket_client_factory,
-        const logger& logger)
+    std::shared_ptr<transport> websocket_transport::create(const std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)>& websocket_client_factory,
+        const signalr_client_config& signalr_client_config, const logger& logger)
     {
         return std::shared_ptr<transport>(
-            new websocket_transport(websocket_client_factory, logger));
+            new websocket_transport(websocket_client_factory, signalr_client_config, logger));
     }
 
-    websocket_transport::websocket_transport(const std::function<std::shared_ptr<websocket_client>()>& websocket_client_factory,
-        const logger& logger)
+    websocket_transport::websocket_transport(const std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)>& websocket_client_factory,
+        const signalr_client_config& signalr_client_config, const logger& logger)
         : transport(logger), m_websocket_client_factory(websocket_client_factory), m_close_callback([](std::exception_ptr) {}),
-        m_process_response_callback([](std::string, std::exception_ptr) {}), m_receive_loop_cts(std::make_shared<cancellation_token>())
+        m_process_response_callback([](std::string, std::exception_ptr) {}), m_receive_loop_cts(std::make_shared<cancellation_token>()),
+        m_signalr_client_config(signalr_client_config)
     {
         // we use this cts to check if the receive loop is running so it should be
         // initially canceled to indicate that the receive loop is not running
@@ -161,7 +162,7 @@ namespace signalr
                 std::string("[websocket transport] connecting to: ")
                 .append(url));
 
-            auto websocket_client = m_websocket_client_factory();
+            auto websocket_client = m_websocket_client_factory(m_signalr_client_config);
 
             {
                 std::lock_guard<std::mutex> client_lock(m_websocket_client_lock);
diff --git a/src/signalrclient/websocket_transport.h b/src/signalrclient/websocket_transport.h
index 35bf8cf7..7f627fac 100644
--- a/src/signalrclient/websocket_transport.h
+++ b/src/signalrclient/websocket_transport.h
@@ -13,8 +13,8 @@ namespace signalr
     class websocket_transport : public transport, public std::enable_shared_from_this<websocket_transport>
     {
     public:
-        static std::shared_ptr<transport> create(const std::function<std::shared_ptr<websocket_client>()>& websocket_client_factory,
-            const logger& logger);
+        static std::shared_ptr<transport> create(const std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)>& websocket_client_factory,
+            const signalr_client_config& signalr_client_config, const logger& logger);
 
         ~websocket_transport();
 
@@ -33,15 +33,16 @@ namespace signalr
         void on_receive(std::function<void(std::string&&, std::exception_ptr)>) override;
 
     private:
-        websocket_transport(const std::function<std::shared_ptr<websocket_client>()>& websocket_client_factory,
-            const logger& logger);
+        websocket_transport(const std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)>& websocket_client_factory,
+            const signalr_client_config& signalr_client_config, const logger& logger);
 
-        std::function<std::shared_ptr<websocket_client>()> m_websocket_client_factory;
+        std::function<std::shared_ptr<websocket_client>(const signalr_client_config&)> m_websocket_client_factory;
         std::shared_ptr<websocket_client> m_websocket_client;
         std::mutex m_websocket_client_lock;
         std::mutex m_start_stop_lock;
         std::function<void(std::string, std::exception_ptr)> m_process_response_callback;
         std::function<void(std::exception_ptr)> m_close_callback;
+        signalr_client_config m_signalr_client_config;
 
         std::shared_ptr<cancellation_token> m_receive_loop_cts;
 
diff --git a/submodules/vcpkg b/submodules/vcpkg
index b9f30b71..586bee9b 160000
--- a/submodules/vcpkg
+++ b/submodules/vcpkg
@@ -1 +1 @@
-Subproject commit b9f30b7197fd5874aa919e85ce6fabafa790a3c4
+Subproject commit 586bee9bcd30993033a3590f7e84ef1b648cad10
diff --git a/test/signalrclienttests/connection_impl_tests.cpp b/test/signalrclienttests/connection_impl_tests.cpp
index 5cf6439a..eaec6b3c 100644
--- a/test/signalrclienttests/connection_impl_tests.cpp
+++ b/test/signalrclienttests/connection_impl_tests.cpp
@@ -17,7 +17,7 @@ static std::shared_ptr<connection_impl> create_connection(std::shared_ptr<websoc
     std::shared_ptr<log_writer> log_writer = std::make_shared<memory_log_writer>(), trace_level trace_level = trace_level::all)
 {
     return connection_impl::create(create_uri(), trace_level, log_writer, create_test_http_client(),
-        [websocket_client]() { return websocket_client; });
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 }
 
 TEST(connection_impl_connection_state, initial_connection_state_is_disconnected)
@@ -137,7 +137,8 @@ TEST(connection_impl_start, throws_for_invalid_uri)
 
     auto websocket_client = create_test_websocket_client();
 
-    auto connection = connection_impl::create(":1\t ä bad_uri&a=b", trace_level::errors, writer, create_test_http_client(), [websocket_client]() { return websocket_client; });
+    auto connection = connection_impl::create(":1\t ä bad_uri&a=b", trace_level::errors, writer, create_test_http_client(),
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -171,7 +172,8 @@ TEST(connection_impl_start, start_sets_id_query_string)
             callback(std::make_exception_ptr(std::runtime_error("connecting failed")));
         });
 
-    auto connection = connection_impl::create(create_uri(""), trace_level::errors, writer, create_test_http_client(), [websocket_client]() { return websocket_client; });
+    auto connection = connection_impl::create(create_uri(""), trace_level::errors, writer, create_test_http_client(),
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -205,7 +207,8 @@ TEST(connection_impl_start, start_appends_id_query_string)
             callback(std::make_exception_ptr(std::runtime_error("connecting failed")));
         });
 
-    auto connection = connection_impl::create(create_uri("a=b&c=d"), trace_level::errors, writer, create_test_http_client(), [websocket_client]() { return websocket_client; });
+    auto connection = connection_impl::create(create_uri("a=b&c=d"), trace_level::errors, writer, create_test_http_client(),
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -379,7 +382,7 @@ TEST(connection_impl_start, start_fails_if_negotiate_request_fails)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -412,21 +415,17 @@ TEST(connection_impl_start, start_fails_if_negotiate_response_has_error)
             return http_response{ 200, response_body };
         });
 
-    pplx::task_completion_event<void> tce;
+    auto connect_mre = manual_reset_event<void>();
     auto websocket_client = std::make_shared<test_websocket_client>();
-    websocket_client->set_connect_function([tce](const std::string&, std::function<void(std::exception_ptr)> callback)
+    websocket_client->set_connect_function([&connect_mre](const std::string&, std::function<void(std::exception_ptr)> callback)
         {
-            pplx::task<void>(tce)
-                .then([callback](pplx::task<void> prev_task)
-                    {
-                        prev_task.get();
-                        callback(nullptr);
-                    });
+            connect_mre.get();
+            callback(nullptr);
         });
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -444,7 +443,7 @@ TEST(connection_impl_start, start_fails_if_negotiate_response_has_error)
         ASSERT_STREQ("bad negotiate", e.what());
     }
 
-    tce.set();
+    connect_mre.set();
 }
 
 TEST(connection_impl_start, start_fails_if_negotiate_response_does_not_have_websockets)
@@ -465,7 +464,7 @@ TEST(connection_impl_start, start_fails_if_negotiate_response_does_not_have_webs
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -502,7 +501,7 @@ TEST(connection_impl_start, start_fails_if_negotiate_response_does_not_have_tran
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -539,7 +538,7 @@ TEST(connection_impl_start, start_fails_if_negotiate_response_is_invalid)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -589,7 +588,7 @@ TEST(connection_impl_start, negotiate_follows_redirect)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -638,7 +637,7 @@ TEST(connection_impl_start, negotiate_redirect_uses_accessToken)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -672,7 +671,7 @@ TEST(connection_impl_start, negotiate_fails_after_too_many_redirects)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -710,7 +709,7 @@ TEST(connection_impl_start, negotiate_fails_if_ProtocolVersion_in_response)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -757,7 +756,7 @@ TEST(connection_impl_start, negotiate_redirect_does_not_overwrite_url)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -813,7 +812,8 @@ TEST(connection_impl_start, negotiate_redirect_uses_own_query_string)
             return http_response{ 200, response_body };
         });
 
-    auto connection = connection_impl::create(create_uri("a=b&c=d"), trace_level::errors, writer, std::move(http_client), [websocket_client]() { return websocket_client; });
+    auto connection = connection_impl::create(create_uri("a=b&c=d"), trace_level::errors, writer, std::move(http_client),
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -860,7 +860,8 @@ TEST(connection_impl_start, negotiate_with_negotiateVersion_uses_connectionToken
             return http_response{ 200, response_body };
         });
 
-    auto connection = connection_impl::create(create_uri(), trace_level::errors, writer, std::move(http_client), [websocket_client]() { return websocket_client; });
+    auto connection = connection_impl::create(create_uri(), trace_level::errors, writer, std::move(http_client),
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -905,7 +906,8 @@ TEST(connection_impl_start, correct_connection_id_returned_with_negotiateVersion
             return http_response{ 200, response_body };
         });
 
-    auto connection = connection_impl::create(create_uri(), trace_level::errors, writer, std::move(http_client), [websocket_client]() { return websocket_client; });
+    auto connection = connection_impl::create(create_uri(), trace_level::errors, writer, std::move(http_client),
+        [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -924,21 +926,19 @@ TEST(connection_impl_start, start_fails_if_connect_request_times_out)
 
     auto http_client = create_test_http_client();
 
-    pplx::task_completion_event<void> tce;
+    auto connect_mre = manual_reset_event<void>();
+    auto wait_connect_mre = manual_reset_event<void>();
     auto websocket_client = std::make_shared<test_websocket_client>();
-    websocket_client->set_connect_function([tce](const std::string&, std::function<void(std::exception_ptr)> callback)
+    websocket_client->set_connect_function([&connect_mre, &wait_connect_mre](const std::string&, std::function<void(std::exception_ptr)> callback)
         {
-            pplx::task<void>(tce)
-                .then([callback](pplx::task<void> prev_task)
-                    {
-                        prev_task.get();
-                        callback(nullptr);
-                    });
+            connect_mre.get();
+            callback(nullptr);
+            wait_connect_mre.set();
         });
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::messages, writer,
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -956,7 +956,8 @@ TEST(connection_impl_start, start_fails_if_connect_request_times_out)
         ASSERT_STREQ("transport timed out when trying to connect", e.what());
     }
 
-    tce.set();
+    connect_mre.set();
+    wait_connect_mre.get();
 }
 
 TEST(connection_impl_process_response, process_response_logs_messages)
@@ -1277,11 +1278,8 @@ TEST(connection_impl_stop, stopping_disconnecting_connection_returns_canceled_ta
         /* connect function */ [&close_event](const std::string&, std::function<void(std::exception_ptr)> callback) { callback(nullptr); },
         /* close function */ [&close_event](std::function<void(std::exception_ptr)> callback)
         {
-            pplx::create_task([&close_event, callback]()
-                {
-                    close_event.wait();
-                    callback(nullptr);
-                });
+            close_event.wait();
+            callback(nullptr);
         });
 
     auto connection = create_connection(websocket_client, writer, trace_level::state_changes);
@@ -1472,7 +1470,7 @@ TEST(connection_impl_stop, stop_cancels_ongoing_start_request)
 
     auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };
     auto connection = connection_impl::create(create_uri(), trace_level::all, writer,
-        std::move(http_client), [websocket_client]() { return websocket_client; });
+        std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -1529,7 +1527,7 @@ TEST(connection_impl_stop, DISABLED_ongoing_start_request_canceled_if_connection
 
     auto writer = std::shared_ptr<log_writer>{ std::make_shared<memory_log_writer>() };
     auto connection = connection_impl::create(create_uri(), trace_level::all, writer,
-        std::move(http_client), [websocket_client]() { return websocket_client; });
+        std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
@@ -1695,11 +1693,11 @@ TEST(connection_impl_config, custom_headers_set_in_requests)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::state_changes,
-            writer, std::move(http_client), [websocket_client]() { return websocket_client; });
+            writer, std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     signalr::signalr_client_config signalr_client_config{};
     auto http_headers = signalr_client_config.get_http_headers();
-    http_headers[_XPLATSTR("Answer")] = _XPLATSTR("42");
+    http_headers["Answer"] = "42";
     signalr_client_config.set_http_headers(http_headers);
     connection->set_client_config(signalr_client_config);
 
@@ -1862,7 +1860,7 @@ TEST(connection_id, connection_id_reset_when_starting_connection)
 
     auto connection =
         connection_impl::create(create_uri(), trace_level::none, std::make_shared<memory_log_writer>(),
-            std::move(http_client), [websocket_client]() { return websocket_client; });
+            std::move(http_client), [websocket_client](const signalr_client_config&) { return websocket_client; });
 
     auto mre = manual_reset_event<void>();
     connection->start([&mre](std::exception_ptr exception)
diff --git a/test/signalrclienttests/hub_connection_tests.cpp b/test/signalrclienttests/hub_connection_tests.cpp
index 3d27d588..3391f50f 100644
--- a/test/signalrclienttests/hub_connection_tests.cpp
+++ b/test/signalrclienttests/hub_connection_tests.cpp
@@ -18,7 +18,7 @@ hub_connection create_hub_connection(std::shared_ptr<websocket_client> websocket
     return hub_connection_builder::create(create_uri())
         .with_logging(log_writer, trace_level)
         .with_http_client(create_test_http_client())
-        .with_websocket_factory([websocket_client]() { return websocket_client; })
+        .with_websocket_factory([websocket_client](const signalr_client_config&) { return websocket_client; })
         .build();
 }
 
@@ -109,7 +109,7 @@ TEST(url, negotiate_appended_to_url)
         auto hub_connection = hub_connection_builder::create(base_url)
             .with_logging(std::make_shared<memory_log_writer>(), trace_level::none)
             .with_http_client(http_client)
-            .with_websocket_factory([]() { return create_test_websocket_client(); })
+            .with_websocket_factory([](const signalr_client_config&) { return create_test_websocket_client(); })
             .build();
 
         auto mre = manual_reset_event<void>();
@@ -848,8 +848,6 @@ TEST(send, creates_correct_payload)
 
 TEST(send, does_not_wait_for_server_response)
 {
-    pplx::task_completion_event<void> waitForSend;
-
     auto websocket_client = create_test_websocket_client();
 
     auto hub_connection = create_hub_connection(websocket_client);
@@ -872,7 +870,6 @@ TEST(send, does_not_wait_for_server_response)
         mre.set(exception);
     });
     mre.get();
-    waitForSend.set();
 }
 
 TEST(send, passing_non_array_arguments_fails)
diff --git a/test/signalrclienttests/logger_tests.cpp b/test/signalrclienttests/logger_tests.cpp
index d3f5760a..9c3f6916 100644
--- a/test/signalrclienttests/logger_tests.cpp
+++ b/test/signalrclienttests/logger_tests.cpp
@@ -3,10 +3,10 @@
 
 #include "stdafx.h"
 #include "test_utils.h"
-#include "cpprest/asyncrt_utils.h"
 #include "trace_log_writer.h"
 #include "logger.h"
 #include "memory_log_writer.h"
+#include <regex>
 
 using namespace signalr;
 TEST(logger_write, entry_added_if_trace_level_set)
@@ -61,9 +61,11 @@ TEST(logger_write, entries_formatted_correctly)
 
     auto entry = log_entries[0];
 
-    auto date_str = entry.substr(0, entry.find_first_of("Z") + 1);
-    auto date = utility::datetime::from_string(utility::conversions::to_string_t(date_str), utility::datetime::ISO_8601);
-    ASSERT_EQ(date_str, utility::conversions::to_utf8string(date.to_string(utility::datetime::ISO_8601)));
+    //0000-0-00T00:00:00Z [message     ] message\n
+    std::regex r{ "[\\d]{4}-[\\d]{2}-[\\d]{2}T[\\d]{2}:[\\d]{2}:[\\d]{2}Z \\[message     \\] message\\n" };
+    ASSERT_TRUE(std::regex_match(entry, r));
 
-    ASSERT_EQ("[message     ] message\n", remove_date_from_log_entry(entry));
+    auto expected_message = std::string("[message     ] message\n");
+    auto pos = entry.find(expected_message);
+    ASSERT_EQ(expected_message.size(), entry.size() - pos);
 }
diff --git a/test/signalrclienttests/websocket_transport_tests.cpp b/test/signalrclienttests/websocket_transport_tests.cpp
index 431c2fb7..8ee7f5b9 100644
--- a/test/signalrclienttests/websocket_transport_tests.cpp
+++ b/test/signalrclienttests/websocket_transport_tests.cpp
@@ -25,7 +25,7 @@ TEST(websocket_transport_connect, connect_connects_and_starts_receive_loop)
 
     std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(writer, trace_level::info));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&) { return client; }, signalr_client_config{}, logger(writer, trace_level::info));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://fakeuri.org/connect?param=42", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -50,10 +50,10 @@ TEST(websocket_transport_connect, connect_propagates_exceptions)
     auto client = std::make_shared<test_websocket_client>();
     client->set_connect_function([](const std::string&, std::function<void(std::exception_ptr)> callback)
     {
-        callback(std::make_exception_ptr(web::websockets::client::websocket_exception(_XPLATSTR("connecting failed"))));
+        callback(std::make_exception_ptr(std::runtime_error("connecting failed")));
     });
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     try
     {
@@ -67,7 +67,7 @@ TEST(websocket_transport_connect, connect_propagates_exceptions)
     }
     catch (const std::exception &e)
     {
-        ASSERT_EQ(_XPLATSTR("connecting failed"), utility::conversions::to_string_t(e.what()));
+        ASSERT_STREQ("connecting failed", e.what());
     }
 }
 
@@ -80,7 +80,7 @@ TEST(websocket_transport_connect, connect_logs_exceptions)
     });
 
     std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(writer, trace_level::errors));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(writer, trace_level::errors));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://fakeuri.org", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -107,7 +107,7 @@ TEST(websocket_transport_connect, connect_logs_exceptions)
 TEST(websocket_transport_connect, cannot_call_connect_on_already_connected_transport)
 {
     auto client = std::make_shared<test_websocket_client>();
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://fakeuri.org", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -127,14 +127,14 @@ TEST(websocket_transport_connect, cannot_call_connect_on_already_connected_trans
     }
     catch (const std::exception &e)
     {
-        ASSERT_EQ(_XPLATSTR("transport already connected"), utility::conversions::to_string_t(e.what()));
+        ASSERT_STREQ("transport already connected", e.what());
     }
 }
 
 TEST(websocket_transport_connect, can_connect_after_disconnecting)
 {
     auto client = std::make_shared<test_websocket_client>();
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://fakeuri.org", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -168,7 +168,7 @@ TEST(websocket_transport_send, send_creates_and_sends_websocket_messages)
         callback(nullptr);
     });
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://url", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -198,7 +198,7 @@ TEST(websocket_transport_disconnect, disconnect_closes_websocket)
         callback(nullptr);
     });
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://url", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -227,7 +227,7 @@ TEST(websocket_transport_stop, propogates_exception_from_close)
         callback(std::make_exception_ptr(std::exception()));
     });
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://url", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -255,12 +255,12 @@ TEST(websocket_transport_disconnect, disconnect_logs_exceptions)
     auto client = std::make_shared<test_websocket_client>();
     client->set_close_function([](std::function<void(std::exception_ptr)> callback)
     {
-        callback(std::make_exception_ptr(web::websockets::client::websocket_exception(_XPLATSTR("connection closing failed"))));
+        callback(std::make_exception_ptr(std::runtime_error("connection closing failed")));
     });
 
     std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(writer, trace_level::errors));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(writer, trace_level::errors));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://url", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -305,7 +305,7 @@ TEST(websocket_transport_disconnect, receive_not_called_after_disconnect)
         callback(nullptr);
     });
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://fakeuri.org", transfer_format::text, [&mre](std::exception_ptr)
@@ -350,7 +350,7 @@ TEST(websocket_transport_disconnect, disconnect_is_no_op_if_transport_not_starte
         callback(nullptr);
     });
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     auto mre = manual_reset_event<void>();
     ws_transport->stop([&mre](std::exception_ptr exception)
@@ -379,7 +379,7 @@ void receive_loop_logs_exception_runner(const T& e, const std::string& expected_
     auto client = std::make_shared<test_websocket_client>();
     std::shared_ptr<log_writer> writer(std::make_shared<memory_log_writer>());
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(writer, trace_level));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&) { return client; }, signalr_client_config{}, logger(writer, trace_level));
 
     auto mre = manual_reset_event<void>();
     ws_transport->start("ws://url", transfer_format::text, [&mre](std::exception_ptr exception)
@@ -429,7 +429,7 @@ TEST(websocket_transport_receive_loop, process_response_callback_called_when_mes
         process_response_event->cancel();
     };
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
     ws_transport->on_receive(process_response);
 
     auto mre = manual_reset_event<void>();
@@ -473,7 +473,7 @@ TEST(websocket_transport_receive_loop, error_callback_called_when_exception_thro
         error_event->cancel();
     };
 
-    auto ws_transport = websocket_transport::create([&](){ return client; }, logger(std::make_shared<trace_log_writer>(), trace_level::none));
+    auto ws_transport = websocket_transport::create([&](const signalr_client_config&){ return client; }, signalr_client_config{}, logger(std::make_shared<trace_log_writer>(), trace_level::none));
     ws_transport->on_close(error_callback);
 
     auto mre = manual_reset_event<void>();
@@ -494,7 +494,7 @@ TEST(websocket_transport_receive_loop, error_callback_called_when_exception_thro
 TEST(websocket_transport_get_transport_type, get_transport_type_returns_websockets)
 {
     auto ws_transport = websocket_transport::create(
-        [](){ return std::make_shared<default_websocket_client>(); },
+        [](const signalr_client_config&){ return std::make_shared<test_websocket_client>(); }, signalr_client_config{},
         logger(std::make_shared<trace_log_writer>(), trace_level::none));
 
     ASSERT_EQ(transport_type::websockets, ws_transport->get_transport_type());