feat: propagating opts from client.base (#223)

## Problem

Currently, method `GenServer.call` used on transports have a default
timeout of 5s.
Despite allowing to pass http options such as the timeout to be used in
the request, the GenServer will throw a timeout after 5s.
## Solution

Use a timeout param on `GenServer.call` from opts

## Rationale

opts will allow us to propagate any other config in the future

Author: yoschihirokaimoto

lib/hermes/client/base.ex

@@ -793,6 +793,7 @@ defmodule Hermes.Client.Base do
   @impl true
   def handle_call({:operation, %Operation{} = operation}, from, state) do
     method = operation.method
+    opts = [headers: operation.headers, timeout: operation.timeout]
 
     params_with_token =
       State.add_progress_token_to_params(operation.params, operation.progress_opts)
@@ -801,7 +802,7 @@ defmodule Hermes.Client.Base do
          {request_id, updated_state} =
            State.add_request_from_operation(state, operation, from),
          {:ok, request_data} <- encode_request(method, params_with_token, request_id),
-         :ok <- send_to_transport(state.transport, request_data, operation.headers) do
+         :ok <- send_to_transport(state.transport, request_data, opts) do
       Telemetry.execute(
         Telemetry.event_client_request(),
         %{system_time: System.system_time()},
@@ -1421,24 +1422,12 @@ defmodule Hermes.Client.Base do
     send_notification(state, "notifications/cancelled", params)
   end
 
-  defp send_to_transport(transport, data, headers) when not is_nil(headers) do
-    opts = [headers: headers]
-
+  defp send_to_transport(transport, data, opts \\ []) do
     with {:error, reason} <- transport.layer.send_message(transport.name, data, opts) do
       {:error, Error.transport(:send_failure, %{original_reason: reason})}
     end
   end
 
-  defp send_to_transport(transport, data, _headers) do
-    send_to_transport(transport, data)
-  end
-
-  defp send_to_transport(transport, data) do
-    with {:error, reason} <- transport.layer.send_message(transport.name, data) do
-      {:error, Error.transport(:send_failure, %{original_reason: reason})}
-    end
-  end
-
   defp send_notification(state, method, params \\ %{}) do
     with {:ok, notification_data} <- encode_notification(method, params) do
       send_to_transport(state.transport, notification_data)
@@ -1532,7 +1521,7 @@ defmodule Hermes.Client.Base do
 
   defp send_sampling_response(id, response, state) do
     transport = state.transport
-    :ok = transport.layer.send_message(transport.name, response)
+    :ok = transport.layer.send_message(transport.name, response, [])
 
     Telemetry.execute(
       Telemetry.event_client_response(),
@@ -1544,7 +1533,7 @@ defmodule Hermes.Client.Base do
   defp send_sampling_error(id, message, code, reason, %{transport: transport} = state) do
     error = %Error{code: -1, message: message, data: %{"reason" => reason}}
     {:ok, response} = Error.to_json_rpc(error, id)
-    :ok = transport.layer.send_message(transport.name, response)
+    :ok = transport.layer.send_message(transport.name, response, [])
 
     Logging.client_event(
       "sampling_error",

lib/hermes/server/transport/sse.ex

@@ -131,8 +131,8 @@ defmodule Hermes.Server.Transport.SSE do
     * `{:error, reason}` otherwise
   """
   @impl Transport
-  @spec send_message(GenServer.server(), binary()) :: :ok | {:error, term()}
-  def send_message(transport, message) when is_binary(message) do
+  @spec send_message(GenServer.server(), binary(), keyword()) :: :ok | {:error, term()}
+  def send_message(transport, message, _opts \\ []) when is_binary(message) do
     GenServer.call(transport, {:send_message, message})
   end
 

lib/hermes/server/transport/stdio.ex

@@ -77,8 +77,8 @@ defmodule Hermes.Server.Transport.STDIO do
     * `{:error, reason}` otherwise
   """
   @impl Transport
-  @spec send_message(GenServer.server(), binary()) :: :ok | {:error, term()}
-  def send_message(transport, message) when is_binary(message) do
+  @spec send_message(GenServer.server(), binary(), keyword()) :: :ok | {:error, term()}
+  def send_message(transport, message, _opts \\ []) when is_binary(message) do
     GenServer.cast(transport, {:send, message})
   end
 
@@ -262,7 +262,7 @@ defmodule Hermes.Server.Transport.STDIO do
     else
       case GenServer.call(server, {:request, message, "stdio", context}, timeout) do
         {:ok, response} when is_binary(response) ->
-          send_message(self(), response)
+          send_message(self(), response, [])
 
         {:error, reason} ->
           Logging.transport_event("server_error", %{reason: reason}, level: :error)

lib/hermes/server/transport/streamable_http.ex

@@ -105,8 +105,8 @@ defmodule Hermes.Server.Transport.StreamableHTTP do
     * `{:error, reason}` otherwise
   """
   @impl Transport
-  @spec send_message(GenServer.server(), binary()) :: :ok | {:error, term()}
-  def send_message(transport, message) when is_binary(message) do
+  @spec send_message(GenServer.server(), binary(), keyword()) :: :ok | {:error, term()}
+  def send_message(transport, message, _opts \\ []) when is_binary(message) do
     GenServer.call(transport, {:send_message, message})
   end
 

lib/hermes/transport/behaviour.ex

@@ -11,7 +11,7 @@ defmodule Hermes.Transport.Behaviour do
   @type reason :: term() | Error.t()
 
   @callback start_link(keyword()) :: GenServer.on_start()
-  @callback send_message(t(), message()) :: :ok | {:error, reason()}
+  @callback send_message(t(), message(), keyword()) :: :ok | {:error, reason()}
   @callback shutdown(t()) :: :ok | {:error, reason()}
 
   @doc """

lib/hermes/transport/sse.ex

@@ -101,7 +101,7 @@ defmodule Hermes.Transport.SSE do
   end
 
   @impl Transport
-  def send_message(pid, message) when is_binary(message) do
+  def send_message(pid, message, _opts \\ []) when is_binary(message) do
     GenServer.call(pid, {:send, message})
   end
 

lib/hermes/transport/stdio.ex

@@ -73,7 +73,7 @@ defmodule Hermes.Transport.STDIO do
   end
 
   @impl Transport
-  def send_message(pid \\ __MODULE__, message) when is_binary(message) do
+  def send_message(pid \\ __MODULE__, message, _opts \\ []) when is_binary(message) do
     GenServer.call(pid, {:send, message})
   end
 

lib/hermes/transport/streamable_http.ex

@@ -52,6 +52,8 @@ defmodule Hermes.Transport.StreamableHTTP do
   alias Hermes.Telemetry
   alias Hermes.Transport.Behaviour, as: Transport
 
+  @default_timeout 15_000
+
   @type t :: GenServer.server()
   @type params_t :: Enumerable.t(option)
 
@@ -97,7 +99,8 @@ defmodule Hermes.Transport.StreamableHTTP do
 
   @impl Transport
   def send_message(pid \\ __MODULE__, message, opts \\ []) when is_binary(message) do
-    GenServer.call(pid, {:send, message, opts})
+    timeout = Keyword.get(opts, :timeout, @default_timeout)
+    GenServer.call(pid, {:send, message, opts}, timeout)
   end
 
   @impl Transport

lib/hermes/transport/websocket.ex

@@ -81,7 +81,7 @@ if Code.ensure_loaded?(:gun) do
     end
 
     @impl Transport
-    def send_message(pid, message) when is_binary(message) do
+    def send_message(pid, message, _opts \\ []) when is_binary(message) do
       GenServer.call(pid, {:send, message})
     end