sc-ruby_llm-mcp 0.3.1

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/requests/tool_call.rb

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class RubyLLM::MCP::Requests::ToolList < RubyLLM::MCP::Requests::Base
+  def call
+    client.request(tool_list_body)
+  end
+
+  private
+
+  def tool_list_body
+    {
+      jsonrpc: "2.0",
+      method: "tools/list",
+      params: {}
+    }
+  end
+end

data/lib/ruby_llm/mcp/resource.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Resource
+      attr_reader :uri, :name, :description, :mime_type, :coordinator
+
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
+        @uri = resource["uri"]
+        @name = resource["name"]
+        @description = resource["description"]
+        @mime_type = resource["mimeType"]
+        if resource.key?("content_response")
+          @content_response = resource["content_response"]
+          @content = @content_response["text"] || @content_response["blob"]
+        end
+      end
+
+      def content
+        return @content unless @content.nil?
+
+        response = read_response
+        @content_response = response.dig("result", "contents", 0)
+        @content = @content_response["text"] || @content_response["blob"]
+      end
+
+      def include(chat, **args)
+        message = Message.new(
+          role: "user",
+          content: to_content(**args)
+        )
+
+        chat.add_message(message)
+      end
+
+      def to_content
+        content = self.content
+
+        case content_type
+        when "text"
+          MCP::Content.new(text: "#{name}: #{description}\n\n#{content}")
+        when "blob"
+          attachment = MCP::Attachment.new(content, mime_type)
+          MCP::Content.new(text: "#{name}: #{description}", attachments: [attachment])
+        end
+      end
+
+      private
+
+      def content_type
+        return "text" if @content_response.nil?
+
+        if @content_response.key?("blob")
+          "blob"
+        else
+          "text"
+        end
+      end
+
+      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 ||= @coordinator.resource_read(uri: uri)
+        end
+      end
+
+      def fetch_uri_content(uri)
+        response = Faraday.get(uri)
+        { "result" => { "contents" => [{ "text" => response.body }] } }
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/resource_template.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class ResourceTemplate
+      attr_reader :uri, :name, :description, :mime_type, :coordinator, :template
+
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
+        @uri = resource["uriTemplate"]
+        @name = resource["name"]
+        @description = resource["description"]
+        @mime_type = resource["mimeType"]
+      end
+
+      def fetch_resource(arguments: {})
+        uri = apply_template(@uri, arguments)
+        response = read_response(uri)
+        content_response = response.dig("result", "contents", 0)
+
+        Resource.new(coordinator, {
+                       "uri" => uri,
+                       "name" => "#{@name} (#{uri})",
+                       "description" => @description,
+                       "mimeType" => @mime_type,
+                       "content_response" => content_response
+                     })
+      end
+
+      def to_content(arguments: {})
+        fetch_resource(arguments: arguments).to_content
+      end
+
+      def complete(argument, 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"])
+        else
+          raise Errors::CompletionNotAvailable.new(message: "Completion is not available for this MCP server")
+        end
+      end
+
+      private
+
+      def content_type
+        if @content.key?("type")
+          @content["type"]
+        else
+          "text"
+        end
+      end
+
+      def read_response(uri)
+        parsed = URI.parse(uri)
+        case parsed.scheme
+        when "http", "https"
+          fetch_uri_content(uri)
+        else # file:// or git://
+          @coordinator.resource_read(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_s] ||
+            arguments[::Regexp.last_match(1).to_sym] ||
+            "{#{::Regexp.last_match(1)}}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Tool < RubyLLM::Tool
+      attr_reader :name, :description, :parameters, :coordinator, :tool_response
+
+      def initialize(coordinator, tool_response)
+        super()
+        @coordinator = coordinator
+
+        @name = tool_response["name"]
+        @description = tool_response["description"].to_s
+        @parameters = create_parameters(tool_response["inputSchema"])
+      end
+
+      def execute(**params)
+        response = @coordinator.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
+
+      def create_parameters(input_schema)
+        params = {}
+        return params if input_schema["properties"].nil?
+
+        input_schema["properties"].each_key do |key|
+          param_data = input_schema.dig("properties", key)
+
+          param = if param_data.key?("oneOf") || param_data.key?("anyOf") || param_data.key?("allOf")
+                    process_union_parameter(key, param_data)
+                  else
+                    process_parameter(key, param_data)
+                  end
+
+          params[key] = param
+        end
+
+        params
+      end
+
+      def process_union_parameter(key, param_data)
+        union_type = param_data.keys.first
+        param = RubyLLM::MCP::Parameter.new(
+          key,
+          type: :union,
+          union_type: union_type
+        )
+
+        param.properties = param_data[union_type].map do |value|
+          process_parameter(key, value, lifted_type: param_data["type"])
+        end.compact
+
+        param
+      end
+
+      def process_parameter(key, param_data, lifted_type: nil)
+        param = RubyLLM::MCP::Parameter.new(
+          key,
+          type: param_data["type"] || lifted_type,
+          desc: param_data["description"],
+          required: param_data["required"]
+        )
+
+        if param.type == :array
+          items = param_data["items"]
+          param.items = items
+          if items.key?("properties")
+            param.properties = create_parameters(items)
+          end
+          if param_data.key?("enum")
+            param.enum = param_data["enum"]
+          end
+        elsif param.type == :object
+          if param_data.key?("properties")
+            param.properties = create_parameters(param_data)
+          end
+        end
+
+        param
+      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["data"], content["mimeType"])
+          MCP::Content.new(text: nil, attachments: [attachment])
+        when "resource"
+          resource_data = {
+            "name" => name,
+            "description" => description,
+            "uri" => content.dig("resource", "uri"),
+            "content" => content["resource"]
+          }
+
+          resource = Resource.new(coordinator, resource_data)
+          resource.to_content
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "faraday"
+require "timeout"
+require "securerandom"
+
+module RubyLLM
+  module MCP
+    module Transport
+      class SSE
+        attr_reader :headers, :id
+
+        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}"
+          @root_url += ":#{uri.port}" if uri.port != uri.default_port
+
+          @client_id = SecureRandom.uuid
+          @headers = headers.merge({
+                                     "Accept" => "text/event-stream",
+                                     "Cache-Control" => "no-cache",
+                                     "Connection" => "keep-alive",
+                                     "X-CLIENT-ID" => @client_id
+                                   })
+
+          @id_counter = 0
+          @id_mutex = Mutex.new
+          @pending_requests = {}
+          @pending_mutex = Mutex.new
+          @connection_mutex = Mutex.new
+          @running = true
+          @sse_thread = nil
+
+          # Start the SSE listener thread
+          start_sse_listener
+        end
+
+        def request(body, add_id: true, wait_for_response: true) # rubocop:disable Metrics/MethodLength
+          # Generate a unique 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
+          if wait_for_response
+            @pending_mutex.synchronize do
+              @pending_requests[request_id.to_s] = response_queue
+            end
+          end
+
+          # Send the request using Faraday
+          begin
+            conn = Faraday.new do |f|
+              f.options.timeout = @request_timeout / 1000
+              f.options.open_timeout = 5
+            end
+
+            response = conn.post(@messages_url) do |req|
+              @headers.each do |key, value|
+                req.headers[key] = value
+              end
+              req.headers["Content-Type"] = "application/json"
+              req.body = JSON.generate(body)
+            end
+
+            unless response.status == 200
+              @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+              raise "Failed to request #{@messages_url}: #{response.status} - #{response.body}"
+            end
+          rescue StandardError => e
+            @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+            raise e
+          end
+          return unless wait_for_response
+
+          begin
+            Timeout.timeout(@request_timeout / 1000) do
+              response_queue.pop
+            end
+          rescue Timeout::Error
+            @pending_mutex.synchronize { @pending_requests.delete(request_id.to_s) }
+            raise RubyLLM::MCP::Errors::TimeoutError.new(
+              message: "Request timed out after #{@request_timeout / 1000} seconds"
+            )
+          end
+        end
+
+        def alive?
+          @running
+        end
+
+        def close
+          @running = false
+          @sse_thread&.join(1) # Give the thread a second to clean up
+          @sse_thread = nil
+        end
+
+        private
+
+        def start_sse_listener
+          @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
+
+            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&.alive?
+        end
+
+        def listen_for_events
+          stream_events_from_server
+        rescue Faraday::Error => e
+          handle_connection_error("SSE connection failed", e)
+        rescue StandardError => e
+          handle_connection_error("SSE connection error", e)
+        end
+
+        def stream_events_from_server
+          buffer = +""
+          create_sse_connection.get(@event_url) do |req|
+            setup_request_headers(req)
+            setup_streaming_callback(req, buffer)
+          end
+        end
+
+        def create_sse_connection
+          Faraday.new do |f|
+            f.options.timeout = 300 # 5 minutes
+            f.response :raise_error # raise errors on non-200 responses
+          end
+        end
+
+        def setup_request_headers(request)
+          @headers.each do |key, value|
+            request.headers[key] = value
+          end
+        end
+
+        def setup_streaming_callback(request, buffer)
+          request.options.on_data = proc do |chunk, _size, _env|
+            buffer << chunk
+            process_buffer_events(buffer)
+          end
+        end
+
+        def process_buffer_events(buffer)
+          while (event = extract_event(buffer))
+            event_data, buffer = event
+            process_event(event_data) if event_data
+          end
+        end
+
+        def handle_connection_error(message, error)
+          puts "#{message}: #{error.message}. Reconnecting in 3 seconds..."
+          sleep 3
+        end
+
+        def process_event(raw_event)
+          return if raw_event[:data].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
+          end
+
+          @pending_mutex.synchronize do
+            if request_id && @pending_requests.key?(request_id)
+              response_queue = @pending_requests.delete(request_id)
+              response_queue&.push(event)
+            end
+          end
+        rescue JSON::ParserError => e
+          puts "Error parsing event data: #{e.message}"
+        end
+
+        def extract_event(buffer)
+          return nil unless buffer.include?("\n\n")
+
+          raw, rest = buffer.split("\n\n", 2)
+          [parse_event(raw), rest]
+        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)
+            end
+          end
+          event[:data] = event[:data]&.join("\n")
+          event
+        end
+      end
+    end
+  end
+end