revert: revert cache impl (#221)

## Problem

Unexpected timeout when calling mcp tools (second and beyond)

## Solution

Removing the faulty cache implementation

## Rationale

Revert

Author: yoschihirokaimoto

lib/hermes/client/base.ex

@@ -6,7 +6,6 @@ defmodule Hermes.Client.Base do
 
   import Peri
 
-  alias Hermes.Client.Cache
   alias Hermes.Client.Operation
   alias Hermes.Client.Request
   alias Hermes.Client.State
@@ -1110,8 +1109,6 @@ defmodule Hermes.Client.Base do
       })
     end
 
-    Cache.cleanup(state.client_info["name"])
-
     state.transport.layer.shutdown(state.transport.name)
   end
 
@@ -1178,15 +1175,15 @@ defmodule Hermes.Client.Base do
       method: request.method
     })
 
-    meta =
-      if is_map(error),
-        do: %{error_code: error["code"], error_message: error["message"]},
-        else: %{errors: Enum.map(error, &Peri.Error.error_to_map/1)}
-
     Telemetry.execute(
       Telemetry.event_client_error(),
       %{duration: elapsed_ms, system_time: System.system_time()},
-      Map.merge(%{id: id, method: request.method}, meta)
+      %{
+        id: id,
+        method: request.method,
+        error_code: error["code"],
+        error_message: error["message"]
+      }
     )
   end
 
@@ -1225,44 +1222,6 @@ defmodule Hermes.Client.Base do
     end
   end
 
-  defp process_successful_response(%{method: "tools/call"} = request, result, id, state) do
-    response = Response.from_json_rpc(%{"result" => result, "id" => id})
-    response = %{response | method: request.method}
-    elapsed_ms = Request.elapsed_time(request)
-
-    client = state.client_info["name"]
-    structured = result["structuredContent"]
-    tool = request.params["name"]
-    validator = Cache.get_tool_validator(client, tool)
-
-    if is_map(structured) and is_function(validator, 1) do
-      case validator.(structured) do
-        {:ok, _} ->
-          GenServer.reply(request.from, {:ok, response})
-
-        {:error, errors} ->
-          log_error_response(request, id, elapsed_ms, errors)
-
-          GenServer.reply(
-            request.from,
-            {:error,
-             Error.protocol(:parse_error, %{
-               errors: errors,
-               tool: tool,
-               request_id: request.id,
-               request_params: request.params,
-               request_method: request.method
-             })}
-          )
-      end
-    else
-      log_success_response(request, id, elapsed_ms)
-      GenServer.reply(request.from, {:ok, response})
-    end
-
-    state
-  end
-
   defp process_successful_response(request, result, id, state) do
     response = Response.from_json_rpc(%{"result" => result, "id" => id})
     response = %{response | method: request.method}
@@ -1273,13 +1232,6 @@ defmodule Hermes.Client.Base do
     method = request.method
     from = request.from
 
-    if method == "tools/list" do
-      tools = response.result["tools"]
-      client = state.client_info["name"]
-      Cache.clear_tool_validators(client)
-      Cache.put_tool_validators(client, tools)
-    end
-
     if method == "ping",
       do: GenServer.reply(from, :pong),
       else: GenServer.reply(from, {:ok, response})

test/hermes/client/base_test.exs

@@ -1378,112 +1378,6 @@ defmodule Hermes.Client.BaseTest do
   describe "tool output schema validation caching" do
     setup :initialized_client
 
-    test "validates tool call output when structuredContent is present", %{client: client} do
-      expect(Hermes.MockTransport, :send_message, fn _, message ->
-        decoded = JSON.decode!(message)
-        assert decoded["method"] == "tools/list"
-        :ok
-      end)
-
-      list_task = Task.async(fn -> Hermes.Client.Base.list_tools(client) end)
-      Process.sleep(50)
-
-      request_id = get_request_id(client, "tools/list")
-
-      tools = [
-        %{
-          "name" => "get_weather",
-          "outputSchema" => %{
-            "type" => "object",
-            "properties" => %{
-              "temperature" => %{"type" => "number"},
-              "conditions" => %{"type" => "string"}
-            },
-            "required" => ["temperature", "conditions"]
-          }
-        }
-      ]
-
-      response = tools_list_response(request_id, tools)
-      send_response(client, response)
-      assert {:ok, _} = Task.await(list_task)
-
-      expect(Hermes.MockTransport, :send_message, fn _, message ->
-        decoded = JSON.decode!(message)
-        assert decoded["method"] == "tools/call"
-        assert decoded["params"]["name"] == "get_weather"
-        :ok
-      end)
-
-      call_task =
-        Task.async(fn ->
-          Hermes.Client.Base.call_tool(client, "get_weather", %{"location" => "NYC"})
-        end)
-
-      Process.sleep(50)
-      call_request_id = get_request_id(client, "tools/call")
-
-      valid_structured = %{
-        "temperature" => 72.5,
-        "conditions" => "sunny"
-      }
-
-      content = [
-        %{
-          "type" => "text",
-          "text" => "The weather in NYC is 72.5°F and sunny"
-        }
-      ]
-
-      response = %{
-        "jsonrpc" => "2.0",
-        "id" => call_request_id,
-        "result" => %{
-          "content" => content,
-          "structuredContent" => valid_structured,
-          "isError" => false
-        }
-      }
-
-      send_response(client, response)
-
-      assert {:ok, response} = Task.await(call_task)
-      assert response.result["structuredContent"] == valid_structured
-
-      expect(Hermes.MockTransport, :send_message, fn _, _ -> :ok end)
-
-      invalid_task =
-        Task.async(fn ->
-          Hermes.Client.Base.call_tool(client, "get_weather", %{"location" => "LA"})
-        end)
-
-      Process.sleep(50)
-      invalid_request_id = get_request_id(client, "tools/call")
-
-      invalid_structured = %{
-        "temperature" => "not a number",
-        "conditions" => "cloudy"
-      }
-
-      invalid_response = %{
-        "jsonrpc" => "2.0",
-        "id" => invalid_request_id,
-        "result" => %{
-          "content" => content,
-          "structuredContent" => invalid_structured,
-          "isError" => false
-        }
-      }
-
-      send_response(client, invalid_response)
-
-      assert {:error, error} = Task.await(invalid_task)
-      assert error.reason == :parse_error
-      assert error.data[:tool] == "get_weather"
-      assert is_list(error.data[:errors])
-      assert length(error.data[:errors]) > 0
-    end
-
     test "handles tools with complex outputSchema", %{client: client} do
       expect(Hermes.MockTransport, :send_message, fn _, _ -> :ok end)