sc-ruby_llm-mcp 0.3.1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Errors
+      class BaseError < StandardError
+        attr_reader :message
+
+        def initialize(message:)
+          @message = message
+          super(message)
+        end
+      end
+
+      class CompletionNotAvailable < BaseError; end
+
+      class PromptArgumentError < BaseError; end
+
+      class InvalidProtocolVersionError < BaseError; end
+
+      class SessionExpiredError < BaseError; end
+
+      class TimeoutError < BaseError; end
+
+      class InvalidTransportType < BaseError; end
+    end
+  end
+end

data/lib/ruby_llm/mcp/parameter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Parameter < RubyLLM::Parameter
+      attr_accessor :items, :properties, :enum, :union_type
+
+      def initialize(name, type: "string", desc: nil, required: true, union_type: nil)
+        super(name, type: type.to_sym, desc: desc, required: required)
+        @properties = {}
+        @union_type = union_type
+      end
+
+      def item_type
+        @items["type"].to_sym
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/prompt.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Prompt
+      class Argument
+        attr_reader :name, :description, :required
+
+        def initialize(name:, description:, required:)
+          @name = name
+          @description = description
+          @required = required
+        end
+      end
+
+      attr_reader :name, :description, :arguments, :coordinator
+
+      def initialize(coordinator, prompt)
+        @coordinator = coordinator
+        @name = prompt["name"]
+        @description = prompt["description"]
+        @arguments = parse_arguments(prompt["arguments"])
+      end
+
+      def fetch(arguments = {})
+        fetch_prompt_messages(arguments)
+      end
+
+      def include(chat, arguments: {})
+        validate_arguments!(arguments)
+        messages = fetch_prompt_messages(arguments)
+
+        messages.each { |message| chat.add_message(message) }
+        chat
+      end
+
+      def ask(chat, arguments: {}, &)
+        include(chat, arguments: arguments)
+
+        chat.complete(&)
+      end
+
+      alias say ask
+
+      def complete(argument, 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"])
+        else
+          raise Errors::CompletionNotAvailable.new(message: "Completion is not available for this MCP server")
+        end
+      end
+
+      private
+
+      def fetch_prompt_messages(arguments)
+        response = @coordinator.execute_prompt(
+          name: @name,
+          arguments: arguments
+        )
+
+        response["result"]["messages"].map do |message|
+          content = create_content_for_message(message["content"])
+
+          RubyLLM::Message.new(
+            role: message["role"],
+            content: content
+          )
+        end
+      end
+
+      def validate_arguments!(incoming_arguments)
+        @arguments.each do |arg|
+          if arg.required && incoming_arguments.key?(arg.name)
+            raise Errors::PromptArgumentError, "Argument #{arg.name} is required"
+          end
+        end
+      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(coordinator, content["resource"])
+          resource.to_content
+        end
+      end
+
+      def parse_arguments(arguments)
+        if arguments.nil?
+          []
+        else
+          arguments.map do |arg|
+            Argument.new(name: arg["name"], description: arg["description"], required: arg["required"])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Providers
+      module Anthropic
+        module ComplexParameterSupport
+          module_function
+
+          def clean_parameters(parameters)
+            parameters.transform_values do |param|
+              build_properties(param).compact
+            end
+          end
+
+          def required_parameters(parameters)
+            parameters.select { |_, param| param.required }.keys
+          end
+
+          def build_properties(param)
+            case param.type
+            when :array
+              if param.item_type == :object
+                {
+                  type: param.type,
+                  items: { type: param.item_type, properties: clean_parameters(param.properties) }
+                }
+              else
+                {
+                  type: param.type,
+                  items: { type: param.item_type, enum: param.enum }.compact
+                }
+              end
+            when :object
+              {
+                type: param.type,
+                properties: clean_parameters(param.properties),
+                required: required_parameters(param.properties)
+              }
+            when :union
+              {
+                param.union_type => param.properties.map { |property| build_properties(property) }
+              }
+            else
+              {
+                type: param.type,
+                description: param.description
+              }.compact
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module RubyLLM::Providers::Anthropic::Tools
+  def self.clean_parameters(parameters)
+    RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport.clean_parameters(parameters)
+  end
+
+  def self.required_parameters(parameters)
+    RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport.required_parameters(parameters)
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Providers
+      module Gemini
+        module ComplexParameterSupport
+          module_function
+
+          # Format tool parameters for Gemini API
+          def format_parameters(parameters)
+            {
+              type: "OBJECT",
+              properties: parameters.transform_values { |param| build_properties(param) },
+              required: parameters.select { |_, p| p.required }.keys.map(&:to_s)
+            }
+          end
+
+          def build_properties(param)
+            properties = case param.type
+                         when :array
+                           if param.item_type == :object
+                             {
+                               type: param_type_for_gemini(param.type),
+                               items: {
+                                 type: param_type_for_gemini(param.item_type),
+                                 properties: param.properties.transform_values { |value| build_properties(value) }
+                               }
+                             }
+                           else
+                             {
+                               type: param_type_for_gemini(param.type),
+                               items: { type: param_type_for_gemini(param.item_type), enum: param.enum }.compact
+                             }
+                           end
+                         when :object
+                           {
+                             type: param_type_for_gemini(param.type),
+                             properties: param.properties.transform_values { |value| build_properties(value) },
+                             required: param.properties.select { |_, p| p.required }.keys
+                           }
+                         when :union
+                           {
+                             param.union_type => param.properties.map { |properties| build_properties(properties) }
+                           }
+                         else
+                           {
+                             type: param_type_for_gemini(param.type),
+                             description: param.description
+                           }
+                         end
+
+            properties.compact
+          end
+        end
+      end
+    end
+  end
+end
+
+RubyLLM::Providers::Gemini.extend(RubyLLM::MCP::Providers::Gemini::ComplexParameterSupport)

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Providers
+      module OpenAI
+        module ComplexParameterSupport
+          module_function
+
+          def param_schema(param)
+            properties = case param.type
+                         when :array
+                           if param.item_type == :object
+                             {
+                               type: param.type,
+                               items: {
+                                 type: param.item_type,
+                                 properties: param.properties.transform_values { |value| param_schema(value) }
+                               }
+                             }
+                           else
+                             {
+                               type: param.type,
+                               items: { type: param.item_type, enum: param.enum }.compact
+                             }
+                           end
+                         when :object
+                           {
+                             type: param.type,
+                             properties: param.properties.transform_values { |value| param_schema(value) },
+                             required: param.properties.select { |_, p| p.required }.keys
+                           }
+                         when :union
+                           {
+                             param.union_type => param.properties.map { |property| param_schema(property) }
+                           }
+                         else
+                           {
+                             type: param.type,
+                             description: param.description
+                           }.compact
+                         end
+
+            properties.compact
+          end
+        end
+      end
+    end
+  end
+end
+
+RubyLLM::Providers::OpenAI.extend(RubyLLM::MCP::Providers::OpenAI::ComplexParameterSupport)

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Base
+        attr_reader :client
+
+        def initialize(client)
+          @client = client
+        end
+
+        def call
+          raise "Not implemented"
+        end
+
+        private
+
+        def validate_response!(response, body)
+          # TODO: Implement response validation
+        end
+
+        def raise_error(error)
+          raise "MCP Error: code: #{error['code']} message: #{error['message']} data: #{error['data']}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class CompletionPrompt
+        def initialize(client, name:, argument:, value:)
+          @client = client
+          @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/prompt",
+                name: @name
+              },
+              argument: {
+                name: @argument,
+                value: @value
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class CompletionResource
+        def initialize(client, uri:, argument:, value:)
+          @client = client
+          @uri = uri
+          @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/resource",
+                uri: @uri
+              },
+              argument: {
+                name: @argument,
+                value: @value
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class RubyLLM::MCP::Requests::Initialization < RubyLLM::MCP::Requests::Base
+  def call
+    client.request(initialize_body)
+  end
+
+  private
+
+  def initialize_body
+    {
+      jsonrpc: "2.0",
+      method: "initialize",
+      params: {
+        protocolVersion: @client.protocol_version,
+        capabilities: {},
+        clientInfo: {
+          name: "RubyLLM-MCP Client",
+          version: RubyLLM::MCP::VERSION
+        }
+      }
+    }
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class RubyLLM::MCP::Requests::InitializeNotification < RubyLLM::MCP::Requests::Base
+  def call
+    client.request(notification_body, add_id: false, wait_for_response: false)
+  end
+
+  def notification_body
+    {
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    }
+  end
+end

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