ruby_llm-mcp 0.0.2 → 0.2.0

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

@@ -5,20 +5,36 @@ module RubyLLM
     module Providers
       module Anthropic
         module ComplexParameterSupport
+          module_function
+
           def clean_parameters(parameters)
             parameters.transform_values do |param|
-              format = {
-                type: param.type,
-                description: param.description
-              }.compact
+              build_properties(param).compact
+            end
+          end
 
-              if param.type == "array"
-                format[:items] = param.items
-              elsif param.type == "object"
-                format[:properties] = clean_parameters(param.properties)
-              end
+          def required_parameters(parameters)
+            parameters.select { |_, param| param.required }.keys
+          end
 
-              format
+          def build_properties(param)
+            case param.type
+            when :array
+              {
+                type: param.type,
+                items: { type: param.item_type }
+              }
+            when :object
+              {
+                type: param.type,
+                properties: clean_parameters(param.properties),
+                required: required_parameters(param.properties)
+              }
+            else
+              {
+                type: param.type,
+                description: param.description
+              }
             end
           end
         end

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

@@ -5,18 +5,29 @@ module RubyLLM
     module Providers
       module OpenAI
         module ComplexParameterSupport
+          module_function
+
           def param_schema(param)
-            format = {
-              type: param.type,
-              description: param.description
-            }.compact
+            properties = case param.type
+                         when :array
+                           {
+                             type: param.type,
+                             items: { type: param.item_type }
+                           }
+                         when :object
+                           {
+                             type: param.type,
+                             properties: param.properties.transform_values { |value| param_schema(value) },
+                             required: param.properties.select { |_, p| p.required }.keys
+                           }
+                         else
+                           {
+                             type: param.type,
+                             description: param.description
+                           }
+                         end
 
-            if param.type == "array"
-              format[:items] = param.items
-            elsif param.type == "object"
-              format[:properties] = param.properties.transform_values { |value| param_schema(value) }
-            end
-            format
+            properties.compact
           end
         end
       end

data/lib/ruby_llm/mcp/requests/completion.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Completion
+        def initialize(client, type:, name:, argument:, value:)
+          @client = client
+          @type = type
+          @name = name
+          @argument = argument
+          @value = value
+        end
+
+        def call
+          @client.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "completion/complete",
+            params: {
+              ref: {
+                type: ref_type,
+                name: @name
+              },
+              argument: {
+                name: @argument,
+                value: @value
+              }
+            }
+          }
+        end
+
+        def ref_type
+          case @type
+          when :prompt
+            "ref/prompt"
+          when :resource
+            "ref/resource"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/initialization.rb

@@ -12,14 +12,10 @@ class RubyLLM::MCP::Requests::Initialization < RubyLLM::MCP::Requests::Base
       jsonrpc: "2.0",
       method: "initialize",
       params: {
-        protocolVersion: RubyLLM::MCP::Client::PROTOCOL_VERSION,
-        capabilities: {
-          tools: {
-            listChanged: true
-          }
-        },
+        protocolVersion: @client.protocol_version,
+        capabilities: {},
         clientInfo: {
-          name: "RubyLLM MCP Client",
+          name: "RubyLLM-MCP Client",
           version: RubyLLM::MCP::VERSION
         }
       }

data/lib/ruby_llm/mcp/requests/notification.rb

@@ -2,7 +2,7 @@
 
 class RubyLLM::MCP::Requests::Notification < RubyLLM::MCP::Requests::Base
   def call
-    client.request(notification_body, wait_for_response: false)
+    client.request(notification_body, add_id: false, wait_for_response: false)
   end
 
   def notification_body

data/lib/ruby_llm/mcp/requests/prompt_call.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class PromptCall
+        def initialize(client, name:, arguments: {})
+          @client = client
+          @name = name
+          @arguments = arguments
+        end
+
+        def call
+          @client.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            method: "prompts/get",
+            params: {
+              name: @name,
+              arguments: @arguments
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/prompt_list.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class PromptList < Base
+        def call
+          client.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            method: "prompts/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/resource_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceList < Base
+        def call
+          client.request(resource_list_body)
+        end
+
+        def resource_list_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/resource_read.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceRead
+        attr_reader :client, :uri
+
+        def initialize(client, uri:)
+          @client = client
+          @uri = uri
+        end
+
+        def call
+          client.request(reading_resource_body(uri))
+        end
+
+        def reading_resource_body(uri)
+          {
+            jsonrpc: "2.0",
+            method: "resources/read",
+            params: {
+              uri: uri
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/resource_template_list.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceTemplateList < Base
+        def call
+          client.request(resource_template_list_body)
+        end
+
+        def resource_template_list_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/templates/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/resource.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Resource
+      attr_reader :uri, :name, :description, :mime_type, :mcp_client, :template
+
+      def initialize(mcp_client, resource, template: false)
+        @mcp_client = mcp_client
+        @uri = resource["uri"]
+        @name = resource["name"]
+        @description = resource["description"]
+        @mime_type = resource["mimeType"]
+        @content = resource["content"] || nil
+        @template = template
+      end
+
+      def content(arguments: {})
+        return @content if @content && !template?
+
+        response = if template?
+                     templated_uri = apply_template(@uri, arguments)
+
+                     read_response(uri: templated_uri)
+                   else
+                     read_response
+                   end
+
+        content = response.dig("result", "contents", 0)
+        @type = if content.key?("type")
+                  content["type"]
+                else
+                  "text"
+                end
+
+        @content = content["text"] || content["blob"]
+      end
+
+      def include(chat, **args)
+        message = Message.new(
+          role: "user",
+          content: to_content(**args)
+        )
+
+        chat.add_message(message)
+      end
+
+      def to_content(arguments: {})
+        content = content(arguments: arguments)
+
+        case @type
+        when "text"
+          MCP::Content.new(content)
+        when "blob"
+          attachment = MCP::Attachment.new(content, mime_type)
+          MCP::Content.new(text: "#{name}: #{description}", attachments: [attachment])
+        end
+      end
+
+      def arguments_search(argument, value)
+        if template? && @mcp_client.capabilities.completion?
+          response = @mcp_client.completion(type: :resource, name: @name, argument: argument, value: value)
+          response = response.dig("result", "completion")
+
+          Completion.new(values: response["values"], total: response["total"], has_more: response["hasMore"])
+        else
+          raise Errors::CompletionNotAvailable, "Completion is not available for this MCP server"
+        end
+      end
+
+      def template?
+        @template
+      end
+
+      private
+
+      def read_response(uri: @uri)
+        parsed = URI.parse(uri)
+        case parsed.scheme
+        when "http", "https"
+          fetch_uri_content(uri)
+        else # file:// or git://
+          @read_response ||= @mcp_client.resource_read_request(uri: uri)
+        end
+      end
+
+      def fetch_uri_content(uri)
+        response = Faraday.get(uri)
+        { "result" => { "contents" => [{ "text" => response.body }] } }
+      end
+
+      def apply_template(uri, arguments)
+        uri.gsub(/\{(\w+)\}/) do
+          arguments[::Regexp.last_match(1).to_sym] || "{#{::Regexp.last_match(1)}}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -15,10 +15,17 @@ module RubyLLM
       end
 
       def execute(**params)
-        @mcp_client.execute_tool(
+        response = @mcp_client.execute_tool(
           name: @name,
           parameters: params
         )
+
+        text_values = response.dig("result", "content").map { |content| content["text"] }.compact.join("\n")
+        if text_values.empty?
+          create_content_for_message(response.dig("result", "content", 0))
+        else
+          create_content_for_message({ type: "text", text: text_values })
+        end
       end
 
       private
@@ -45,6 +52,19 @@ module RubyLLM
 
         params
       end
+
+      def create_content_for_message(content)
+        case content["type"]
+        when "text"
+          MCP::Content.new(text: content["text"])
+        when "image", "audio"
+          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.to_content
+        end
+      end
     end
   end
 end

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

@@ -14,7 +14,12 @@ module RubyLLM
 
         def initialize(url, headers: {})
           @event_url = url
-          @messages_url = url.gsub("sse", "messages")
+          @messages_url = nil
+
+          uri = URI.parse(url)
+          @root_url = "#{uri.scheme}://#{uri.host}"
+          @root_url += ":#{uri.port}" if uri.port != uri.default_port
+
           @client_id = SecureRandom.uuid
           @headers = headers.merge({
                                      "Accept" => "text/event-stream",
@@ -35,11 +40,14 @@ module RubyLLM
           start_sse_listener
         end
 
-        def request(body, wait_for_response: true)
+        # rubocop:disable Metrics/MethodLength
+        def request(body, add_id: true, wait_for_response: true)
           # Generate a unique request ID
-          @id_mutex.synchronize { @id_counter += 1 }
-          request_id = @id_counter
-          body["id"] = request_id
+          if add_id
+            @id_mutex.synchronize { @id_counter += 1 }
+            request_id = @id_counter
+            body["id"] = request_id
+          end
 
           # Create a queue for this request's response
           response_queue = Queue.new
@@ -83,6 +91,7 @@ module RubyLLM
             raise RubyLLM::MCP::Errors::TimeoutError.new(message: "Request timed out after 30 seconds")
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def close
           @running = false
@@ -96,17 +105,35 @@ module RubyLLM
           @connection_mutex.synchronize do
             return if sse_thread_running?
 
+            response_queue = Queue.new
+            @pending_mutex.synchronize do
+              @pending_requests["endpoint"] = response_queue
+            end
+
             @sse_thread = Thread.new do
               listen_for_events while @running
             end
-
             @sse_thread.abort_on_exception = true
-            sleep 0.1 # Wait for the SSE connection to be established
+
+            endpoint = response_queue.pop
+            set_message_endpoint(endpoint)
+
+            @pending_mutex.synchronize { @pending_requests.delete("endpoint") }
           end
         end
 
+        def set_message_endpoint(endpoint)
+          uri = URI.parse(endpoint)
+
+          @messages_url = if uri.host.nil?
+                            "#{@root_url}#{endpoint}"
+                          else
+                            endpoint
+                          end
+        end
+
         def sse_thread_running?
-          @sse_thread && @sse_thread.alive?
+          @sse_thread&.alive?
         end
 
         def listen_for_events
@@ -160,14 +187,19 @@ module RubyLLM
         def process_event(raw_event)
           return if raw_event[:data].nil?
 
-          event = begin
-            JSON.parse(raw_event[:data])
-          rescue StandardError
-            nil
-          end
-          return if event.nil?
+          if raw_event[:event] == "endpoint"
+            request_id = "endpoint"
+            event = raw_event[:data]
+          else
+            event = begin
+              JSON.parse(raw_event[:data])
+            rescue StandardError
+              nil
+            end
+            return if event.nil?
 
-          request_id = event["id"]&.to_s
+            request_id = event["id"]&.to_s
+          end
 
           @pending_mutex.synchronize do
             if request_id && @pending_requests.key?(request_id)

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

@@ -27,10 +27,12 @@ module RubyLLM
           start_process
         end
 
-        def request(body, wait_for_response: true)
-          @id_mutex.synchronize { @id_counter += 1 }
-          request_id = @id_counter
-          body["id"] = request_id
+        def request(body, add_id: true, wait_for_response: true)
+          if add_id
+            @id_mutex.synchronize { @id_counter += 1 }
+            request_id = @id_counter
+            body["id"] = request_id
+          end
 
           response_queue = Queue.new
           if wait_for_response
@@ -150,9 +152,7 @@ module RubyLLM
           response = begin
             JSON.parse(line)
           rescue JSON::ParserError => e
-            puts "Error parsing response as JSON: #{e.message}"
-            puts "Raw response: #{line}"
-            return
+            raise "Error parsing response as JSON: #{e.message}\nRaw response: #{line}"
           end
           request_id = response["id"]&.to_s