ruby_llm-mcp 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02af0c9ae4ba24f6e7af288d77530f87e885e1c0eb594b935bae93916a50870b
-  data.tar.gz: 300b6e91813c6cebe612fe966a84e8dc13beb59ea27f12eb0157624e4eca3655
+  metadata.gz: fa780ea2ca1b1ba71c5efa1784b14e9473ad351af94f0dc35d94aab4d6057325
+  data.tar.gz: 1fd76e02e0f6e22087943eff186dbb05cd059e931927442982752cbb9250aa98
 SHA512:
-  metadata.gz: 9e19267562108057d4a3b031c1859c1569184e77554be2c7af306ed58e5e35cf1c1c184ffcf0be950fef90ce1bf84dd0d5544f72f0b83ac8d7a60eacbef43beb
-  data.tar.gz: abaab7588640608c5bf0df1291c2b05b94794acae6dd5c850f2dd44ce3e259136d330d698cd4455d429ab4641f21b0bf988cec20961362b65392570f964390db
+  metadata.gz: 5c37a73381c487a02d61bb8365e39b064b37a0d0668bd46eae1bd25ad225982c8f15229867cd4110e89689ec5757e395ce3825795298aabc3f4ed3b8cd49e0e5
+  data.tar.gz: ecb7f5524d9af14c3386abb3ddae91bee454046449ae2e0bba758c95060157c057222a57ce1b9eae5af197e5ec8187e34474fb3801b7cdabb92fdb3cbe14ddd2

data/lib/generators/ruby_llm/mcp/install_generator.rb

@@ -19,7 +19,20 @@ module RubyLlm
         end
 
         def display_readme
-          readme "README.txt" if behavior == :invoke
+          return unless behavior == :invoke
+
+          say "✅ RubyLLM MCP installed!", :green
+          say ""
+          say "Next steps:", :blue
+          say "  1. Configure config/initializers/ruby_llm_mcp.rb (main settings)"
+          say "  2. Define servers in config/mcps.yml"
+          say "  3. Install MCP servers (e.g., npm install @modelcontextprotocol/server-filesystem)"
+          say "  4. Set environment variables for authentication"
+          say ""
+          say "📚 Full docs: https://www.rubyllm-mcp.com/", :cyan
+          say ""
+          say "⭐ Help us improve!", :magenta
+          say "  Report issues or show your support with a GitHub star: https://github.com/patvice/ruby_llm-mcp"
         end
       end
     end

data/lib/ruby_llm/mcp/notifications/initialize.rb

@@ -9,7 +9,7 @@ module RubyLLM
         end
 
         def call
-          @coordinator.request(notification_body, add_id: false, wait_for_response: false)
+          @coordinator.request(notification_body, add_id: true, wait_for_response: false)
         end
 
         def notification_body

data/lib/ruby_llm/mcp/parameter.rb

@@ -5,10 +5,11 @@ require "ruby_llm/tool"
 module RubyLLM
   module MCP
     class Parameter < RubyLLM::Parameter
-      attr_accessor :items, :properties, :enum, :union_type, :default
+      attr_accessor :items, :properties, :enum, :union_type, :default, :title
 
-      def initialize(name, type: "string", desc: nil, required: true, default: nil, union_type: nil) # rubocop:disable Metrics/ParameterLists
+      def initialize(name, type: "string", title: nil, desc: nil, required: true, default: nil, union_type: nil) # rubocop:disable Metrics/ParameterLists
         super(name, type: type.to_sym, desc: desc, required: required)
+        @title = title
         @properties = {}
         @union_type = union_type
         @default = default

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

@@ -17,18 +17,20 @@ module RubyLLM
             parameters.select { |_, param| param.required }.keys
           end
 
-          def build_properties(param)
+          def build_properties(param) # rubocop:disable Metrics/MethodLength
             case param.type
             when :array
               if param.item_type == :object
                 {
                   type: param.type,
+                  title: param.title,
                   description: param.description,
                   items: { type: param.item_type, properties: clean_parameters(param.properties) }
                 }.compact
               else
                 {
                   type: param.type,
+                  title: param.title,
                   description: param.description,
                   default: param.default,
                   items: { type: param.item_type, enum: param.enum }.compact
@@ -37,6 +39,7 @@ module RubyLLM
             when :object
               {
                 type: param.type,
+                title: param.title,
                 description: param.description,
                 properties: clean_parameters(param.properties),
                 required: required_parameters(param.properties)
@@ -48,6 +51,7 @@ module RubyLLM
             else
               {
                 type: param.type,
+                title: param.title,
                 description: param.description
               }.compact
             end

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

@@ -22,6 +22,7 @@ module RubyLLM
                            if param.item_type == :object
                              {
                                type: param_type_for_gemini(param.type),
+                               title: param.title,
                                description: param.description,
                                items: {
                                  type: param_type_for_gemini(param.item_type),
@@ -31,6 +32,7 @@ module RubyLLM
                            else
                              {
                                type: param_type_for_gemini(param.type),
+                               title: param.title,
                                description: param.description,
                                default: param.default,
                                items: { type: param_type_for_gemini(param.item_type), enum: param.enum }.compact
@@ -39,6 +41,7 @@ module RubyLLM
                          when :object
                            {
                              type: param_type_for_gemini(param.type),
+                             title: param.title,
                              description: param.description,
                              properties: param.properties.transform_values { |value| build_properties(value) },
                              required: param.properties.select { |_, p| p.required }.keys
@@ -50,6 +53,7 @@ module RubyLLM
                          else
                            {
                              type: param_type_for_gemini(param.type),
+                             title: param.title,
                              description: param.description
                            }
                          end

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

@@ -13,6 +13,7 @@ module RubyLLM
                            if param.item_type == :object
                              {
                                type: param.type,
+                               title: param.title,
                                description: param.description,
                                items: {
                                  type: param.item_type,
@@ -22,6 +23,7 @@ module RubyLLM
                            else
                              {
                                type: param.type,
+                               title: param.title,
                                description: param.description,
                                default: param.default,
                                items: { type: param.item_type, enum: param.enum }.compact
@@ -30,6 +32,7 @@ module RubyLLM
                          when :object
                            {
                              type: param.type,
+                             title: param.title,
                              description: param.description,
                              properties: param.properties.transform_values { |value| param_schema(value) },
                              required: param.properties.select { |_, p| p.required }.keys
@@ -41,6 +44,7 @@ module RubyLLM
                          else
                            {
                              type: param.type,
+                             title: param.title,
                              description: param.description
                            }.compact
                          end

data/lib/ruby_llm/mcp/railtie.rb

@@ -5,9 +5,9 @@ module RubyLLM
     class Railtie < Rails::Railtie
       config.after_initialize do
         if RubyLLM::MCP.config.launch_control == :automatic
-          RubyLLM::MCP.clients.map(&:start)
+          RubyLLM::MCP.clients.each_value.map(&:start)
           at_exit do
-            RubyLLM::MCP.clients.map(&:stop)
+            RubyLLM::MCP.clients.each_value.map(&:stop)
           end
         end
       end

data/lib/ruby_llm/mcp/tool.rb

@@ -25,7 +25,7 @@ module RubyLLM
     end
 
     class Tool < RubyLLM::Tool
-      attr_reader :name, :description, :parameters, :coordinator, :tool_response, :with_prefix
+      attr_reader :name, :title, :description, :parameters, :coordinator, :tool_response, :with_prefix
 
       def initialize(coordinator, tool_response, with_prefix: false)
         super()
@@ -98,6 +98,7 @@ module RubyLLM
 
         schema["properties"].each_key do |key|
           param_data = schema.dig("properties", key)
+          param_data = expand_shorthand_type_to_anyof(param_data)
 
           param = if param_data.key?("oneOf") || param_data.key?("anyOf") || param_data.key?("allOf")
                     process_union_parameter(key, param_data)
@@ -116,11 +117,18 @@ module RubyLLM
         param = RubyLLM::MCP::Parameter.new(
           key,
           type: :union,
+          title: param_data["title"],
+          desc: param_data["description"],
           union_type: union_type
         )
 
         param.properties = param_data[union_type].map do |value|
-          process_parameter(key, value, lifted_type: param_data["type"])
+          expanded_value = expand_shorthand_type_to_anyof(value)
+          if expanded_value.key?("anyOf")
+            process_union_parameter(key, expanded_value)
+          else
+            process_parameter(key, value, lifted_type: param_data["type"])
+          end
         end.compact
 
         param
@@ -129,7 +137,8 @@ module RubyLLM
       def process_parameter(key, param_data, lifted_type: nil)
         param = RubyLLM::MCP::Parameter.new(
           key,
-          type: param_data["type"] || lifted_type,
+          type: param_data["type"] || lifted_type || "string",
+          title: param_data["title"],
           desc: param_data["description"],
           required: param_data["required"],
           default: param_data["default"]
@@ -195,6 +204,21 @@ module RubyLLM
           name
         end
       end
+
+      # Expands shorthand type arrays into explicit anyOf unions
+      # Converts { "type": ["string", "number"] } into { "anyOf": [{"type": "string"}, {"type": "number"}] }
+      # This keeps $ref references clean and provides a consistent structure for union types
+      #
+      # @param param_data [Hash] The parameter data that may contain a shorthand type array
+      # @return [Hash] The expanded parameter data with anyOf, or the original if not a shorthand
+      def expand_shorthand_type_to_anyof(param_data)
+        type = param_data["type"]
+        return param_data unless type.is_a?(Array)
+
+        {
+          "anyOf" => type.map { |t| { "type" => t } }
+        }.merge(param_data.except("type"))
+      end
     end
   end
 end

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

@@ -30,7 +30,6 @@ module RubyLLM
                                      "Accept" => "text/event-stream",
                                      "Content-Type" => "application/json",
                                      "Cache-Control" => "no-cache",
-                                     "Connection" => "keep-alive",
                                      "X-CLIENT-ID" => @client_id
                                    })
 
@@ -167,41 +166,82 @@ module RubyLLM
         end
 
         def stream_events_from_server
-          sse_client = HTTPX.plugin(:stream)
-          sse_client = sse_client.with(
-            headers: @headers
-          )
+          sse_client = create_sse_client
+          response = sse_client.get(@event_url, stream: true)
+          validate_sse_response!(response)
+          process_event_stream(response)
+        end
 
-          if @version == :http1
-            sse_client = sse_client.with(
-              ssl: { alpn_protocols: ["http/1.1"] }
-            )
-          end
+        def create_sse_client
+          sse_client = HTTPX.plugin(:stream).with(headers: @headers)
+          return sse_client unless @version == :http1
 
-          response = sse_client.get(@event_url, stream: true)
+          sse_client.with(ssl: { alpn_protocols: ["http/1.1"] })
+        end
+
+        def validate_sse_response!(response)
+          return unless response.status >= 400
+
+          error_body = read_error_body(response)
+          error_message = "HTTP #{response.status} error from SSE endpoint: #{error_body}"
+          RubyLLM::MCP.logger.error error_message
+
+          handle_client_error!(error_message, response.status) if response.status < 500
+
+          raise StandardError, error_message
+        end
+
+        def handle_client_error!(error_message, status_code)
+          @running = false
+          raise Errors::TransportError.new(
+            message: error_message,
+            code: status_code
+          )
+        end
 
+        def process_event_stream(response)
           event_buffer = []
           response.each_line do |event_line|
-            unless @running
-              response.body.close
-              next
-            end
+            break unless handle_event_line?(event_line, event_buffer, response)
+          end
+        end
 
-            # Strip the line and check if it's empty (indicates end of event)
-            line = event_line.strip
+        def handle_event_line?(event_line, event_buffer, response)
+          unless @running
+            response.body.close
+            return false
+          end
 
-            if line.empty?
-              # End of event - process the accumulated buffer
-              if event_buffer.any?
-                event = parse_event(event_buffer.join("\n"))
-                process_event(event)
-                event_buffer.clear
-              end
-            else
-              # Accumulate the line for the current event
-              event_buffer << line
+          line = event_line.strip
+
+          if line.empty?
+            process_buffered_event(event_buffer)
+          else
+            event_buffer << line
+          end
+
+          true
+        end
+
+        def process_buffered_event(event_buffer)
+          return unless event_buffer.any?
+
+          events = parse_event(event_buffer.join("\n"))
+          events.each { |event| process_event(event) }
+          event_buffer.clear
+        end
+
+        def read_error_body(response)
+          # Try to read the error body from the response
+          body = ""
+          begin
+            response.each do |chunk|
+              body << chunk
             end
+          rescue StandardError
+            # If we can't read the body, just use what we have
           end
+          body.strip.empty? ? "No error details provided" : body.strip
         end
 
         def handle_connection_error(message, error)
@@ -275,19 +315,25 @@ module RubyLLM
         end
 
         def parse_event(raw)
-          event = {}
-          raw.each_line do |line|
-            case line
-            when /^data:\s*(.*)/
-              (event[:data] ||= []) << ::Regexp.last_match(1)
-            when /^event:\s*(.*)/
-              event[:event] = ::Regexp.last_match(1)
-            when /^id:\s*(.*)/
-              event[:id] = ::Regexp.last_match(1)
+          event_blocks = raw.split(/\n\s*\n/)
+
+          events = event_blocks.map do |event_block|
+            event = {}
+            event_block.each_line do |line|
+              case line
+              when /^data:\s*(.*)/
+                (event[:data] ||= []) << ::Regexp.last_match(1)
+              when /^event:\s*(.*)/
+                event[:event] = ::Regexp.last_match(1)
+              when /^id:\s*(.*)/
+                event[:id] = ::Regexp.last_match(1)
+              end
             end
+            event[:data] = event[:data]&.join("\n")
+            event
           end
-          event[:data] = event[:data]&.join("\n")
-          event
+
+          events.reject { |event| event.empty? || event[:data].nil? }
         end
       end
     end

data/lib/ruby_llm/mcp/transports/streamable_http.rb

@@ -122,7 +122,6 @@ module RubyLLM
 
           response_queue = setup_response_queue(request_id, wait_for_response)
           result = send_http_request(body, request_id, is_initialization: is_initialization)
-
           return result if result.is_a?(RubyLLM::MCP::Result)
 
           if wait_for_response && request_id
@@ -365,16 +364,17 @@ module RubyLLM
         end
 
         def handle_success_response(response, request_id, _original_message)
-          # Safely access content type
           content_type = response.respond_to?(:headers) ? response.headers["content-type"] : nil
 
           if content_type&.include?("text/event-stream")
-            # SSE response - let the streaming handler process it
             start_sse_stream
             nil
           elsif content_type&.include?("application/json")
-            # Direct JSON response
             response_body = response.respond_to?(:body) ? response.body.to_s : "{}"
+            if response_body == "null" # Fix related to official MCP Ruby SDK implementation
+              response_body = "{}"
+            end
+
             json_response = JSON.parse(response_body)
             result = RubyLLM::MCP::Result.new(json_response, session_id: @session_id)
 
@@ -594,10 +594,17 @@ module RubyLLM
         end
 
         def extract_sse_event(buffer)
-          return nil unless buffer.include?("\n\n")
-
-          raw, rest = buffer.split("\n\n", 2)
-          [parse_sse_event(raw), rest]
+          # Support both Unix (\n\n) and Windows (\r\n\r\n) line endings
+          separator = if buffer.include?("\r\n\r\n")
+                        "\r\n\r\n"
+                      elsif buffer.include?("\n\n")
+                        "\n\n"
+                      else
+                        return nil
+                      end
+
+          raw, rest = buffer.split(separator, 2)
+          [parse_sse_event(raw), rest || ""]
         end
 
         def parse_sse_event(raw)

data/lib/ruby_llm/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "0.6.1"
+    VERSION = "0.6.3"
   end
 end

data/lib/tasks/release.rake

@@ -4,8 +4,8 @@ namespace :release do
   desc "Release a new version of the gem"
   task :version do
     # Load the current version from version.rb
-    require_relative "../../lib/ruby_llm/schema/version"
-    version = RubyLlm::Schema::VERSION
+    require_relative "../../lib/ruby_llm/mcp/version"
+    version = RubyLLM::MCP::VERSION
 
     puts "Releasing version #{version}..."
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.3
 platform: ruby
 authors:
 - Patrick Vice
@@ -51,20 +51,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -93,7 +79,6 @@ files:
 - LICENSE
 - README.md
 - lib/generators/ruby_llm/mcp/install_generator.rb
-- lib/generators/ruby_llm/mcp/templates/README.txt
 - lib/generators/ruby_llm/mcp/templates/initializer.rb
 - lib/generators/ruby_llm/mcp/templates/mcps.yml
 - lib/ruby_llm/chat.rb

data/lib/generators/ruby_llm/mcp/templates/README.txt

@@ -1,32 +0,0 @@
-RubyLLM MCP has been successfully installed!
-
-The following files have been created:
-
-  config/initializers/ruby_llm_mcp.rb - Main configuration file
-  config/mcps.json                    - MCP servers configuration
-
-Next steps:
-
-1. Edit config/initializers/ruby_llm_mcp.rb to configure your MCP settings
-2. Edit config/mcps.json to define your MCP servers
-3. Install any MCP servers you want to use (e.g., npm install @modelcontextprotocol/server-filesystem) or use remote MCPs
-4. Update environment variables for any MCP servers that require authentication
-
-Example usage in your Rails application:
-
-  # With Ruby::MCP installed in a controller or service
-  clients = RubyLLM::MCP.clients
-
-  # Get all tools use the configured client
-  tools = RubyLLM::MCP.tools
-
-  # Or use the configured client
-  client = RubyLLM::MCP.clients["file-system"]
-
-  # Or use the configured client
-  tools = client.tools
-
-
-For more information, visit: https://github.com/patvice/ruby_llm-mcp
-
-===============================================================================