refactor(s060): the revision pick and the elicit result as their own functions (credo)

Signed-off-by: Ayla Croft <aylacroft@proton.me>

Author: HackTuah

lib/trinity/mcp/client.ex

@@ -317,21 +317,13 @@ defmodule Trinity.MCP.Client do
   defp choose_revision(state) do
     case request(state, Wire.discover(next_id()), connect_timeout(state)) do
       {:ok, %{"result" => %{"supportedVersions" => versions}}} when is_list(versions) ->
-        cond do
-          Wire.modern() in versions -> {:ok, Wire.modern()}
-          Wire.legacy() in versions -> initialize(state)
-          true -> {:refused, {:unsupported_revisions, versions}}
-        end
+        pick(state, versions)
 
       {:ok, %{"error" => %{"code" => -32_601}}} ->
         initialize(state)
 
       {:ok, %{"error" => %{"code" => -32_022} = error}} ->
-        supported = get_in(error, ["data", "supported"]) || []
-
-        if Wire.legacy() in supported,
-          do: initialize(state),
-          else: {:refused, {:unsupported_revisions, supported}}
+        pick(state, List.delete(get_in(error, ["data", "supported"]) || [], Wire.modern()))
 
       {:ok, %{"error" => error}} ->
         {:error, {:discover_refused, error}}
@@ -344,6 +336,17 @@ defmodule Trinity.MCP.Client do
     end
   end
 
+  # The preferred revision when listed, the legacy one when that is, else a refusal naming
+  # the list. (A -32022 refusal of the modern opener lists what the server serves; the
+  # modern revision is removed from that list before the pick, since the server just said no.)
+  defp pick(state, versions) do
+    cond do
+      Wire.modern() in versions -> {:ok, Wire.modern()}
+      Wire.legacy() in versions -> initialize(state)
+      true -> {:refused, {:unsupported_revisions, versions}}
+    end
+  end
+
   defp initialize(state) do
     client_info = %{"name" => "trinity", "version" => to_string(Application.spec(:trinity, :vsn))}
 

lib/trinity_web/components/approval_components.ex

@@ -211,21 +211,21 @@ defmodule TrinityWeb.ApprovalComponents do
     given = Map.get(params, "answer", %{})
 
     for {key, req} <- input_requests(approval), into: %{} do
-      case Map.get(given, key) do
-        %{} = fields ->
-          content =
-            for {name, prop} <- properties(req), Map.has_key?(fields, name), into: %{} do
-              {name, typed(prop, fields[name])}
-            end
-
-          {key, %{"action" => "accept", "content" => content}}
+      {key, elicit_result(req, Map.get(given, key))}
+    end
+  end
 
-        _ ->
-          {key, %{"action" => "decline"}}
+  defp elicit_result(req, %{} = fields) do
+    content =
+      for {name, prop} <- properties(req), Map.has_key?(fields, name), into: %{} do
+        {name, typed(prop, fields[name])}
       end
-    end
+
+    %{"action" => "accept", "content" => content}
   end
 
+  defp elicit_result(_req, _absent), do: %{"action" => "decline"}
+
   defp typed(%{"type" => "boolean"}, v), do: v in ["true", true]
 
   defp typed(%{"type" => "integer"}, v) when is_binary(v) do