ruby_llm-mcp 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c414a0306ebefcb35dcb599406a0092e554e1389aebfa812597e7072e304cf88
-  data.tar.gz: 25b384446ad37b3422bf64e1f9b15413bd8cd64636dbf50ad8ae861e4dc4589d
+  metadata.gz: 53435b09aee8d32aaede3da3463b8fb782a6d00f6abcabc3b9925f1301cd60c9
+  data.tar.gz: 366cf4d89bef7f79904cd897a7db006ee21a8766c8ff1675e51225576e8c87f4
 SHA512:
-  metadata.gz: abbca445c4ecb2ee7a3f2af4457f47aff5337ac981426746184cb0cb63e699b606116d5db983d8d4183557896675743a14bada2af4dd3d54d85066183fe34653
-  data.tar.gz: d8007f3ee983eb3a8e2e76ad2b0daa8ead92bc6347e3352d8d569fab770056026a29237a76182c137459663b54cb4b364df93fb7e968a2d783d1c96fe98f4774
+  metadata.gz: 94754a9b6d8799252bebfb19ccc3dedfc6767fdbe07468960ed3eb56978954d734425f79b366fb92610f4c059970a0607c249b3c6c35bca943fbab7e5a721e77
+  data.tar.gz: d0e757cdc7d064ffc4334b0b1c2a1ebc1feff3dc684d35d28f0b51ce5761a3c80ad427654767fae97da8c8ddacbc182d3d896ef4dedc45ce4d6d8e6297b81fe3

data/lib/ruby_llm/mcp/client.rb

@@ -1,223 +1,103 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module RubyLLM
   module MCP
     class Client
-      PROTOCOL_VERSION = "2025-03-26"
-      PV_2024_11_05 = "2024-11-05"
+      extend Forwardable
 
-      attr_reader :name, :config, :transport_type, :transport, :request_timeout, :reverse_proxy_url, :protocol_version,
-                  :capabilities
+      attr_reader :name, :config, :transport_type, :request_timeout
 
-      def initialize(name:, transport_type:, start: true, request_timeout: 8000, reverse_proxy_url: nil, config: {}) # rubocop:disable Metrics/ParameterLists
+      def initialize(name:, transport_type:, start: true, request_timeout: 8000, config: {})
         @name = name
-        @config = config
-        @protocol_version = PROTOCOL_VERSION
-        @headers = config[:headers] || {}
-
+        @config = config.merge(request_timeout: request_timeout)
         @transport_type = transport_type.to_sym
-        @transport = nil
-
-        @capabilities = nil
-
         @request_timeout = request_timeout
-        @reverse_proxy_url = reverse_proxy_url
 
-        if start
-          self.start
-        end
-      end
+        @coordinator = Coordinator.new(self, transport_type: @transport_type, config: @config)
 
-      def request(body, **options)
-        @transport.request(body, **options)
+        start_transport if start
       end
 
-      def start
-        case @transport_type
-        when :sse
-          @transport = RubyLLM::MCP::Transport::SSE.new(@config[:url], request_timeout: @request_timeout,
-                                                                       headers: @headers)
-        when :stdio
-          @transport = RubyLLM::MCP::Transport::Stdio.new(@config[:command], request_timeout: @request_timeout,
-                                                                             args: @config[:args], env: @config[:env])
-        when :streamable
-          @transport = RubyLLM::MCP::Transport::Streamable.new(@config[:url], request_timeout: @request_timeout,
-                                                                              headers: @headers)
-        else
-          raise "Invalid transport type: #{transport_type}"
-        end
+      def_delegators :@coordinator, :start_transport, :stop_transport, :restart_transport, :alive?, :capabilities
 
-        @initialize_response = initialize_request
-        @capabilities = RubyLLM::MCP::Capabilities.new(@initialize_response["result"]["capabilities"])
-        notification_request
-      end
-
-      def stop
-        @transport&.close
-        @transport = nil
-      end
-
-      def restart!
-        stop
-        start
-      end
-
-      def alive?
-        !!@transport&.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
 
-      def execute_tool(**args)
-        RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
-      end
-
-      def resource_read_request(**args)
-        RubyLLM::MCP::Requests::ResourceRead.new(self, **args).call
-      end
-
-      def completion_resource(**args)
-        RubyLLM::MCP::Requests::CompletionResource.new(self, **args).call
-      end
-
-      def completion_prompt(**args)
-        RubyLLM::MCP::Requests::CompletionPrompt.new(self, **args).call
-      end
-
-      def execute_prompt(**args)
-        RubyLLM::MCP::Requests::PromptCall.new(self, **args).call
-      end
-
       private
 
-      def initialize_request
-        RubyLLM::MCP::Requests::Initialization.new(self).call
-      end
-
-      def notification_request
-        RubyLLM::MCP::Requests::Notification.new(self).call
-      end
-
-      def tool_list_request
-        RubyLLM::MCP::Requests::ToolList.new(self).call
-      end
-
-      def resources_list_request
-        RubyLLM::MCP::Requests::ResourceList.new(self).call
-      end
-
-      def resource_template_list_request
-        RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
-      end
-
-      def prompt_list_request
-        RubyLLM::MCP::Requests::PromptList.new(self).call
-      end
-
-      def fetch_and_create_tools
-        tools_response = tool_list_request
-        tools_response = tools_response["result"]["tools"]
-
-        tools = {}
-        tools_response.each do |tool|
-          new_tool = RubyLLM::MCP::Tool.new(self, tool)
-          tools[new_tool.name] = new_tool
-        end
-
-        tools
-      end
-
-      def fetch_and_create_resources
-        resources_response = resources_list_request
-        resources_response = resources_response["result"]["resources"]
-
-        resources = {}
-        resources_response.each do |resource|
-          new_resource = RubyLLM::MCP::Resource.new(self, resource)
-          resources[new_resource.name] = new_resource
-        end
-
-        resources
+      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_resource_templates
-        resource_templates_response = 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(self, resource_template)
-          resource_templates[new_resource_template.name] = new_resource_template
+      def build_map(raw_data, klass)
+        raw_data.each_with_object({}) do |item, acc|
+          instance = klass.new(@coordinator, item)
+          acc[instance.name] = instance
         end
-
-        resource_templates
-      end
-
-      def fetch_and_create_prompts
-        prompts_response = prompt_list_request
-        prompts_response = prompts_response["result"]["prompts"]
-
-        prompts = {}
-        prompts_response.each do |prompt|
-          new_prompt = RubyLLM::MCP::Prompt.new(self,
-                                                name: prompt["name"],
-                                                description: prompt["description"],
-                                                arguments: prompt["arguments"])
-
-          prompts[new_prompt.name] = new_prompt
-        end
-
-        prompts
       end
     end
   end

data/lib/ruby_llm/mcp/coordinator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Coordinator
+      PROTOCOL_VERSION = "2025-03-26"
+      PV_2024_11_05 = "2024-11-05"
+
+      attr_reader :client, :transport_type, :config, :request_timeout, :headers, :transport, :initialize_response,
+                  :capabilities, :protocol_version
+
+      def initialize(client, transport_type:, config: {})
+        @client = client
+        @transport_type = transport_type
+        @config = config
+
+        @protocol_version = PROTOCOL_VERSION
+        @headers = config[:headers] || {}
+
+        @transport = nil
+        @capabilities = nil
+      end
+
+      def request(body, **options)
+        @transport.request(body, **options)
+      end
+
+      def start_transport
+        case @transport_type
+        when :sse
+          @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: @config[:request_timeout],
+                                                          args: @config[:args],
+                                                          env: @config[:env])
+        when :streamable
+          @transport = RubyLLM::MCP::Transport::Streamable.new(@config[:url],
+                                                               request_timeout: @config[:request_timeout],
+                                                               headers: @headers)
+        else
+          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"])
+        initialize_notification
+      end
+
+      def stop_transport
+        @transport&.close
+        @transport = nil
+      end
+
+      def restart_transport
+        stop_transport
+        start_transport
+      end
+
+      def alive?
+        !!@transport&.alive?
+      end
+
+      def execute_tool(**args)
+        RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
+      end
+
+      def resource_read(**args)
+        RubyLLM::MCP::Requests::ResourceRead.new(self, **args).call
+      end
+
+      def completion_resource(**args)
+        RubyLLM::MCP::Requests::CompletionResource.new(self, **args).call
+      end
+
+      def completion_prompt(**args)
+        RubyLLM::MCP::Requests::CompletionPrompt.new(self, **args).call
+      end
+
+      def execute_prompt(**args)
+        RubyLLM::MCP::Requests::PromptCall.new(self, **args).call
+      end
+
+      def initialize_request
+        RubyLLM::MCP::Requests::Initialization.new(self).call
+      end
+
+      def initialize_notification
+        RubyLLM::MCP::Requests::InitializeNotification.new(self).call
+      end
+
+      def tool_list
+        RubyLLM::MCP::Requests::ToolList.new(self).call
+      end
+
+      def resource_list
+        RubyLLM::MCP::Requests::ResourceList.new(self).call
+      end
+
+      def resource_template_list
+        RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
+      end
+
+      def prompt_list
+        RubyLLM::MCP::Requests::PromptList.new(self).call
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/errors.rb

@@ -12,15 +12,17 @@ module RubyLLM
         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

data/lib/ruby_llm/mcp/parameter.rb

@@ -3,12 +3,13 @@
 module RubyLLM
   module MCP
     class Parameter < RubyLLM::Parameter
-      attr_accessor :items, :properties, :enum, :union_type
+      attr_accessor :items, :properties, :enum, :union_type, :default
 
-      def initialize(name, type: "string", desc: nil, required: true, union_type: nil)
+      def initialize(name, type: "string", desc: nil, required: true, default: nil, union_type: nil) # rubocop:disable Metrics/ParameterLists
         super(name, type: type.to_sym, desc: desc, required: required)
         @properties = {}
         @union_type = union_type
+        @default = default
       end
 
       def item_type

data/lib/ruby_llm/mcp/prompt.rb

@@ -13,13 +13,13 @@ module RubyLLM
         end
       end
 
-      attr_reader :name, :description, :arguments, :mcp_client
+      attr_reader :name, :description, :arguments, :coordinator
 
-      def initialize(mcp_client, name:, description:, arguments:)
-        @mcp_client = mcp_client
-        @name = name
-        @description = description
-        @arguments = parse_arguments(arguments)
+      def initialize(coordinator, prompt)
+        @coordinator = coordinator
+        @name = prompt["name"]
+        @description = prompt["description"]
+        @arguments = parse_arguments(prompt["arguments"])
       end
 
       def fetch(arguments = {})
@@ -43,8 +43,8 @@ module RubyLLM
       alias say ask
 
       def complete(argument, value)
-        if @mcp_client.capabilities.completion?
-          response = @mcp_client.completion_prompt(name: @name, argument: argument, value: value)
+        if @coordinator.capabilities.completion?
+          response = @coordinator.completion_prompt(name: @name, argument: argument, value: value)
           response = response.dig("result", "completion")
 
           Completion.new(values: response["values"], total: response["total"], has_more: response["hasMore"])
@@ -56,7 +56,7 @@ module RubyLLM
       private
 
       def fetch_prompt_messages(arguments)
-        response = @mcp_client.execute_prompt(
+        response = @coordinator.execute_prompt(
           name: @name,
           arguments: arguments
         )
@@ -87,7 +87,7 @@ module RubyLLM
           attachment = MCP::Attachment.new(content["content"], content["mime_type"])
           MCP::Content.new(text: nil, attachments: [attachment])
         when "resource"
-          resource = Resource.new(mcp_client, content["resource"])
+          resource = Resource.new(coordinator, content["resource"])
           resource.to_content
         end
       end

data/lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb

@@ -28,8 +28,9 @@ module RubyLLM
               else
                 {
                   type: param.type,
+                  default: param.default,
                   items: { type: param.item_type, enum: param.enum }.compact
-                }
+                }.compact
               end
             when :object
               {

data/lib/ruby_llm/mcp/providers/gemini/complex_parameter_support.rb

@@ -30,8 +30,9 @@ module RubyLLM
                            else
                              {
                                type: param_type_for_gemini(param.type),
+                               default: param.default,
                                items: { type: param_type_for_gemini(param.item_type), enum: param.enum }.compact
-                             }
+                             }.compact
                            end
                          when :object
                            {

data/lib/ruby_llm/mcp/providers/openai/complex_parameter_support.rb

@@ -21,8 +21,9 @@ module RubyLLM
                            else
                              {
                                type: param.type,
+                               default: param.default,
                                items: { type: param.item_type, enum: param.enum }.compact
-                             }
+                             }.compact
                            end
                          when :object
                            {

data/lib/ruby_llm/mcp/requests/{notification.rb → 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

data/lib/ruby_llm/mcp/resource.rb

@@ -3,10 +3,10 @@
 module RubyLLM
   module MCP
     class Resource
-      attr_reader :uri, :name, :description, :mime_type, :mcp_client
+      attr_reader :uri, :name, :description, :mime_type, :coordinator
 
-      def initialize(mcp_client, resource)
-        @mcp_client = mcp_client
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
         @uri = resource["uri"]
         @name = resource["name"]
         @description = resource["description"]
@@ -64,7 +64,7 @@ module RubyLLM
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @read_response ||= @mcp_client.resource_read_request(uri: uri)
+          @read_response ||= @coordinator.resource_read(uri: uri)
         end
       end
 

data/lib/ruby_llm/mcp/resource_template.rb

@@ -3,10 +3,10 @@
 module RubyLLM
   module MCP
     class ResourceTemplate
-      attr_reader :uri, :name, :description, :mime_type, :mcp_client, :template
+      attr_reader :uri, :name, :description, :mime_type, :coordinator, :template
 
-      def initialize(mcp_client, resource)
-        @mcp_client = mcp_client
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
         @uri = resource["uriTemplate"]
         @name = resource["name"]
         @description = resource["description"]
@@ -18,7 +18,7 @@ module RubyLLM
         response = read_response(uri)
         content_response = response.dig("result", "contents", 0)
 
-        Resource.new(mcp_client, {
+        Resource.new(coordinator, {
                        "uri" => uri,
                        "name" => "#{@name} (#{uri})",
                        "description" => @description,
@@ -32,8 +32,8 @@ module RubyLLM
       end
 
       def complete(argument, value)
-        if @mcp_client.capabilities.completion?
-          response = @mcp_client.completion_resource(uri: @uri, argument: argument, value: value)
+        if @coordinator.capabilities.completion?
+          response = @coordinator.completion_resource(uri: @uri, argument: argument, value: value)
           response = response.dig("result", "completion")
 
           Completion.new(values: response["values"], total: response["total"], has_more: response["hasMore"])
@@ -58,7 +58,7 @@ module RubyLLM
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @mcp_client.resource_read_request(uri: uri)
+          @coordinator.resource_read(uri: uri)
         end
       end
 

data/lib/ruby_llm/mcp/tool.rb

@@ -3,11 +3,11 @@
 module RubyLLM
   module MCP
     class Tool < RubyLLM::Tool
-      attr_reader :name, :description, :parameters, :mcp_client, :tool_response
+      attr_reader :name, :description, :parameters, :coordinator, :tool_response
 
-      def initialize(mcp_client, tool_response)
+      def initialize(coordinator, tool_response)
         super()
-        @mcp_client = mcp_client
+        @coordinator = coordinator
 
         @name = tool_response["name"]
         @description = tool_response["description"].to_s
@@ -15,7 +15,7 @@ module RubyLLM
       end
 
       def execute(**params)
-        response = @mcp_client.execute_tool(
+        response = @coordinator.execute_tool(
           name: @name,
           parameters: params
         )
@@ -70,7 +70,8 @@ module RubyLLM
           key,
           type: param_data["type"] || lifted_type,
           desc: param_data["description"],
-          required: param_data["required"]
+          required: param_data["required"],
+          default: param_data["default"]
         )
 
         if param.type == :array
@@ -79,8 +80,8 @@ module RubyLLM
           if items.key?("properties")
             param.properties = create_parameters(items)
           end
-          if param_data.key?("enum")
-            param.enum = param_data["enum"]
+          if items.key?("enum")
+            param.enum = items["enum"]
           end
         elsif param.type == :object
           if param_data.key?("properties")
@@ -106,7 +107,7 @@ module RubyLLM
             "content" => content["resource"]
           }
 
-          resource = Resource.new(mcp_client, resource_data)
+          resource = Resource.new(coordinator, resource_data)
           resource.to_content
         end
       end

data/lib/ruby_llm/mcp/transport/sse.rb

@@ -12,9 +12,10 @@ module RubyLLM
       class SSE
         attr_reader :headers, :id
 
-        def initialize(url, headers: {})
+        def initialize(url, headers: {}, request_timeout: 8000)
           @event_url = url
           @messages_url = nil
+          @request_timeout = request_timeout
 
           uri = URI.parse(url)
           @root_url = "#{uri.scheme}://#{uri.host}"

data/lib/ruby_llm/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "0.3.0"
+    VERSION = "0.3.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Patrick Vice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-22 00:00:00.000000000 Z
+date: 2025-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -114,6 +114,7 @@ files:
 - lib/ruby_llm/mcp/client.rb
 - lib/ruby_llm/mcp/completion.rb
 - lib/ruby_llm/mcp/content.rb
+- lib/ruby_llm/mcp/coordinator.rb
 - lib/ruby_llm/mcp/errors.rb
 - lib/ruby_llm/mcp/parameter.rb
 - lib/ruby_llm/mcp/prompt.rb
@@ -124,7 +125,7 @@ files:
 - lib/ruby_llm/mcp/requests/completion_prompt.rb
 - lib/ruby_llm/mcp/requests/completion_resource.rb
 - lib/ruby_llm/mcp/requests/initialization.rb
-- lib/ruby_llm/mcp/requests/notification.rb
+- lib/ruby_llm/mcp/requests/initialize_notification.rb
 - lib/ruby_llm/mcp/requests/prompt_call.rb
 - lib/ruby_llm/mcp/requests/prompt_list.rb
 - lib/ruby_llm/mcp/requests/resource_list.rb