continue refactor and fully setup client class

Author: patvice

lib/ruby_llm/mcp/client.rb

@@ -1,149 +1,103 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module RubyLLM
   module MCP
     class Client
-      attr_reader :name, :config, :transport_type, :transport, :request_timeout, :reverse_proxy_url, :protocol_version
+      extend Forwardable
+
+      attr_reader :name, :config, :transport_type, :request_timeout
 
       def initialize(name:, transport_type:, start: true, request_timeout: 8000, config: {})
         @name = name
-        @config = config
+        @config = config.merge(request_timeout: request_timeout)
         @transport_type = transport_type.to_sym
         @request_timeout = request_timeout
-        @config[:request_timeout] = request_timeout
 
-        @coordinator = RubyLLM::MCP::Coordinator.new(self, transport_type: @transport_type, config: config)
+        @coordinator = Coordinator.new(self, transport_type: @transport_type, config: @config)
 
-        if start
-          self.start
-        end
+        start_transport if start
       end
 
-      def capabilities
-        @coordinator.capabilities
-      end
+      def_delegators :@coordinator, :start_transport, :stop_transport, :restart_transport, :alive?, :capabilities
 
-      def start
-        @coordinator.start_transport
-      end
-
-      def stop
-        @coordinator.stop_transport
-      end
-
-      def restart!
-        stop
-        start
-      end
-
-      def alive?
-        @coordinator.alive?
-      end
+      alias start start_transport
+      alias stop stop_transport
+      alias restart! restart_transport
 
       def tools(refresh: false)
-        @tools = nil if refresh
-        @tools ||= fetch_and_create_tools
+        fetch(:tools, refresh) do
+          tools_data = @coordinator.tool_list.dig("result", "tools")
+          build_map(tools_data, MCP::Tool)
+        end
+
         @tools.values
       end
 
       def tool(name, refresh: false)
-        @tools = nil if refresh
-        @tools ||= fetch_and_create_tools
+        tools(refresh: refresh)
 
         @tools[name]
       end
 
       def resources(refresh: false)
-        @resources = nil if refresh
-        @resources ||= fetch_and_create_resources
+        fetch(:resources, refresh) do
+          resources_data = @coordinator.resource_list.dig("result", "resources")
+          build_map(resources_data, MCP::Resource)
+        end
+
         @resources.values
       end
 
       def resource(name, refresh: false)
-        @resources = nil if refresh
-        @resources ||= fetch_and_create_resources
+        resources(refresh: refresh)
 
         @resources[name]
       end
 
       def resource_templates(refresh: false)
-        @resource_templates = nil if refresh
-        @resource_templates ||= fetch_and_create_resource_templates
+        fetch(:resource_templates, refresh) do
+          templates_data = @coordinator.resource_template_list.dig("result", "resourceTemplates")
+          build_map(templates_data, MCP::ResourceTemplate)
+        end
+
         @resource_templates.values
       end
 
       def resource_template(name, refresh: false)
-        @resource_templates = nil if refresh
-        @resource_templates ||= fetch_and_create_resource_templates
+        resource_templates(refresh: refresh)
 
         @resource_templates[name]
       end
 
       def prompts(refresh: false)
-        @prompts = nil if refresh
-        @prompts ||= fetch_and_create_prompts
+        fetch(:prompts, refresh) do
+          prompts_data = @coordinator.prompt_list.dig("result", "prompts")
+          build_map(prompts_data, MCP::Prompt)
+        end
+
         @prompts.values
       end
 
       def prompt(name, refresh: false)
-        @prompts = nil if refresh
-        @prompts ||= fetch_and_create_prompts
+        prompts(refresh: refresh)
 
         @prompts[name]
       end
 
       private
 
-      def fetch_and_create_tools
-        tools_response = @coordinator.tool_list_request
-        tools_response = tools_response["result"]["tools"]
-
-        tools = {}
-        tools_response.each do |tool|
-          new_tool = RubyLLM::MCP::Tool.new(@coordinator, tool)
-          tools[new_tool.name] = new_tool
-        end
-
-        tools
+      def fetch(cache_key, refresh)
+        instance_variable_set("@#{cache_key}", nil) if refresh
+        instance_variable_get("@#{cache_key}") || instance_variable_set("@#{cache_key}", yield)
       end
 
-      def fetch_and_create_resources
-        resources_response = @coordinator.resources_list_request
-        resources_response = resources_response["result"]["resources"]
-
-        resources = {}
-        resources_response.each do |resource|
-          new_resource = RubyLLM::MCP::Resource.new(@coordinator, resource)
-          resources[new_resource.name] = new_resource
+      def build_map(raw_data, klass)
+        raw_data.each_with_object({}) do |item, acc|
+          instance = klass.new(@coordinator, item)
+          acc[instance.name] = instance
         end
-
-        resources
-      end
-
-      def fetch_and_create_resource_templates
-        resource_templates_response = @coordinator.resource_template_list_request
-        resource_templates_response = resource_templates_response["result"]["resourceTemplates"]
-
-        resource_templates = {}
-        resource_templates_response.each do |resource_template|
-          new_resource_template = RubyLLM::MCP::ResourceTemplate.new(@coordinator, resource_template)
-          resource_templates[new_resource_template.name] = new_resource_template
-        end
-
-        resource_templates
-      end
-
-      def fetch_and_create_prompts
-        prompts_response = @coordinator.prompt_list_request
-        prompts_response = prompts_response["result"]["prompts"]
-
-        prompts = {}
-        prompts_response.each do |prompt|
-          new_prompt = RubyLLM::MCP::Prompt.new(@coordinator, prompt)
-          prompts[new_prompt.name] = new_prompt
-        end
-
-        prompts
       end
     end
   end

lib/ruby_llm/mcp/coordinator.rb

@@ -14,9 +14,9 @@ def initialize(client, transport_type:, config: {})
         @transport_type = transport_type
         @config = config
 
-        @request_timeout = config[:request_timeout] || 8000
         @protocol_version = PROTOCOL_VERSION
         @headers = config[:headers] || {}
+
         @transport = nil
         @capabilities = nil
       end
@@ -28,21 +28,26 @@ def request(body, **options)
       def start_transport
         case @transport_type
         when :sse
-          @transport = RubyLLM::MCP::Transport::SSE.new(@config[:url], request_timeout: @request_timeout,
-                                                                       headers: @headers)
+          @transport = RubyLLM::MCP::Transport::SSE.new(@config[:url],
+                                                        request_timeout: @config[:request_timeout],
+                                                        headers: @headers)
         when :stdio
-          @transport = RubyLLM::MCP::Transport::Stdio.new(@config[:command], request_timeout: @request_timeout,
-                                                                             args: @config[:args], env: @config[:env])
+          @transport = RubyLLM::MCP::Transport::Stdio.new(@config[:command],
+                                                          request_timeout: @config[:request_timeout],
+                                                          args: @config[:args],
+                                                          env: @config[:env])
         when :streamable
-          @transport = RubyLLM::MCP::Transport::Streamable.new(@config[:url], request_timeout: @request_timeout,
-                                                                              headers: @headers)
+          @transport = RubyLLM::MCP::Transport::Streamable.new(@config[:url],
+                                                               request_timeout: @config[:request_timeout],
+                                                               headers: @headers)
         else
-          raise "Invalid transport type: #{transport_type}"
+          message = "Invalid transport type: :#{transport_type}. Supported types are :sse, :stdio, :streamable"
+          raise Errors::InvalidTransportType.new(message: message)
         end
 
         @initialize_response = initialize_request
         @capabilities = RubyLLM::MCP::Capabilities.new(@initialize_response["result"]["capabilities"])
-        notification_request
+        initialize_notification
       end
 
       def stop_transport
@@ -63,7 +68,7 @@ def execute_tool(**args)
         RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
       end
 
-      def resource_read_request(**args)
+      def resource_read(**args)
         RubyLLM::MCP::Requests::ResourceRead.new(self, **args).call
       end
 
@@ -83,23 +88,23 @@ def initialize_request
         RubyLLM::MCP::Requests::Initialization.new(self).call
       end
 
-      def notification_request
-        RubyLLM::MCP::Requests::Notification.new(self).call
+      def initialize_notification
+        RubyLLM::MCP::Requests::InitializeNotification.new(self).call
       end
 
-      def tool_list_request
+      def tool_list
         RubyLLM::MCP::Requests::ToolList.new(self).call
       end
 
-      def resources_list_request
+      def resource_list
         RubyLLM::MCP::Requests::ResourceList.new(self).call
       end
 
-      def resource_template_list_request
+      def resource_template_list
         RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
       end
 
-      def prompt_list_request
+      def prompt_list
         RubyLLM::MCP::Requests::PromptList.new(self).call
       end
     end

lib/ruby_llm/mcp/errors.rb

@@ -12,15 +12,17 @@ def initialize(message:)
         end
       end
 
+      class CompletionNotAvailable < BaseError; end
+
+      class PromptArgumentError < BaseError; end
+
       class InvalidProtocolVersionError < BaseError; end
 
       class SessionExpiredError < BaseError; end
 
       class TimeoutError < BaseError; end
 
-      class PromptArgumentError < BaseError; end
-
-      class CompletionNotAvailable < BaseError; end
+      class InvalidTransportType < BaseError; end
     end
   end
 end

lib/ruby_llm/mcp/requests/notification.rb …/mcp/requests/initialize_notification.rblib/ruby_llm/mcp/requests/notification.rb renamed to lib/ruby_llm/mcp/requests/initialize_notification.rb lib/ruby_llm/mcp/requests/notification.rb renamed to lib/ruby_llm/mcp/requests/initialize_notification.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class RubyLLM::MCP::Requests::Notification < RubyLLM::MCP::Requests::Base
+class RubyLLM::MCP::Requests::InitializeNotification < RubyLLM::MCP::Requests::Base
   def call
     client.request(notification_body, add_id: false, wait_for_response: false)
   end

lib/ruby_llm/mcp/resource.rb

@@ -64,7 +64,7 @@ def read_response(uri: @uri)
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @read_response ||= @coordinator.resource_read_request(uri: uri)
+          @read_response ||= @coordinator.resource_read(uri: uri)
         end
       end
 

lib/ruby_llm/mcp/resource_template.rb

@@ -58,7 +58,7 @@ def read_response(uri)
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @coordinator.resource_read_request(uri: uri)
+          @coordinator.resource_read(uri: uri)
         end
       end