ruby_llm-mcp 0.2.1 → 0.3.1

data/lib/ruby_llm/mcp/prompt.rb

@@ -13,16 +13,17 @@ 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
+      def initialize(coordinator, prompt)
+        @coordinator = coordinator
+        @name = prompt["name"]
+        @description = prompt["description"]
+        @arguments = parse_arguments(prompt["arguments"])
+      end
 
-        @arguments = arguments.map do |arg|
-          Argument.new(name: arg["name"], description: arg["description"], required: arg["required"])
-        end
+      def fetch(arguments = {})
+        fetch_prompt_messages(arguments)
       end
 
       def include(chat, arguments: {})
@@ -41,21 +42,21 @@ module RubyLLM
 
       alias say ask
 
-      def arguments_search(argument, value)
-        if @mcp_client.capabilities.completion?
-          response = @mcp_client.completion(type: :prompt, name: @name, argument: argument, value: value)
+      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, "Completion is not available for this MCP server"
+          raise Errors::CompletionNotAvailable.new(message: "Completion is not available for this MCP server")
         end
       end
 
       private
 
       def fetch_prompt_messages(arguments)
-        response = @mcp_client.execute_prompt(
+        response = @coordinator.execute_prompt(
           name: @name,
           arguments: arguments
         )
@@ -86,10 +87,20 @@ 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
+
+      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

@@ -20,21 +20,33 @@ module RubyLLM
           def build_properties(param)
             case param.type
             when :array
-              {
-                type: param.type,
-                items: { type: param.item_type }
-              }
+              if param.item_type == :object
+                {
+                  type: param.type,
+                  items: { type: param.item_type, properties: clean_parameters(param.properties) }
+                }
+              else
+                {
+                  type: param.type,
+                  default: param.default,
+                  items: { type: param.item_type, enum: param.enum }.compact
+                }.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
@@ -43,4 +55,12 @@ module RubyLLM
   end
 end
 
-RubyLLM::Providers::Anthropic.extend(RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport)
+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,62 @@
+# 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),
+                               default: param.default,
+                               items: { type: param_type_for_gemini(param.item_type), enum: param.enum }.compact
+                             }.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

@@ -10,21 +10,36 @@ module RubyLLM
           def param_schema(param)
             properties = case param.type
                          when :array
-                           {
-                             type: param.type,
-                             items: { type: param.item_type }
-                           }
+                           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,
+                               default: param.default,
+                               items: { type: param.item_type, enum: param.enum }.compact
+                             }.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

data/lib/ruby_llm/mcp/requests/{completion.rb → completion_prompt.rb}

@@ -3,10 +3,9 @@
 module RubyLLM
   module MCP
     module Requests
-      class Completion
-        def initialize(client, type:, name:, argument:, value:)
+      class CompletionPrompt
+        def initialize(client, name:, argument:, value:)
           @client = client
-          @type = type
           @name = name
           @argument = argument
           @value = value
@@ -25,7 +24,7 @@ module RubyLLM
             method: "completion/complete",
             params: {
               ref: {
-                type: ref_type,
+                type: "ref/prompt",
                 name: @name
               },
               argument: {
@@ -35,15 +34,6 @@ module RubyLLM
             }
           }
         end
-
-        def ref_type
-          case @type
-          when :prompt
-            "ref/prompt"
-          when :resource
-            "ref/resource"
-          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/{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,37 +3,26 @@
 module RubyLLM
   module MCP
     class Resource
-      attr_reader :uri, :name, :description, :mime_type, :mcp_client, :template
+      attr_reader :uri, :name, :description, :mime_type, :coordinator
 
-      def initialize(mcp_client, resource, template: false)
-        @mcp_client = mcp_client
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
         @uri = resource["uri"]
         @name = resource["name"]
         @description = resource["description"]
         @mime_type = resource["mimeType"]
-        @content = resource["content"] || nil
-        @template = template
+        if resource.key?("content_response")
+          @content_response = resource["content_response"]
+          @content = @content_response["text"] || @content_response["blob"]
+        end
       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
+      def content
+        return @content unless @content.nil?
 
-        @content = content["text"] || content["blob"]
+        response = read_response
+        @content_response = response.dig("result", "contents", 0)
+        @content = @content_response["text"] || @content_response["blob"]
       end
 
       def include(chat, **args)
@@ -45,42 +34,37 @@ module RubyLLM
         chat.add_message(message)
       end
 
-      def to_content(arguments: {})
-        content = content(arguments: arguments)
+      def to_content
+        content = self.content
 
-        case @type
+        case content_type
         when "text"
-          MCP::Content.new(content)
+          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
 
-      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")
+      private
+
+      def content_type
+        return "text" if @content_response.nil?
 
-          Completion.new(values: response["values"], total: response["total"], has_more: response["hasMore"])
+        if @content_response.key?("blob")
+          "blob"
         else
-          raise Errors::CompletionNotAvailable, "Completion is not available for this MCP server"
+          "text"
         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)
+          @read_response ||= @coordinator.resource_read(uri: uri)
         end
       end
 
@@ -88,12 +72,6 @@ module RubyLLM
         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/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

@@ -3,28 +3,29 @@
 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"]
+        @description = tool_response["description"].to_s
         @parameters = create_parameters(tool_response["inputSchema"])
       end
 
       def execute(**params)
-        response = @mcp_client.execute_tool(
+        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 })
+          create_content_for_message({ "type" => "text", "text" => text_values })
         end
       end
 
@@ -32,20 +33,16 @@ module RubyLLM
 
       def create_parameters(input_schema)
         params = {}
+        return params if input_schema["properties"].nil?
+
         input_schema["properties"].each_key do |key|
-          param = RubyLLM::MCP::Parameter.new(
-            key,
-            type: input_schema["properties"][key]["type"],
-            desc: input_schema["properties"][key]["description"],
-            required: input_schema["properties"][key]["required"]
-          )
-
-          if param.type == "array"
-            param.items = input_schema["properties"][key]["items"]
-          elsif param.type == "object"
-            properties = create_parameters(input_schema["properties"][key]["properties"])
-            param.properties = properties
-          end
+          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
@@ -53,15 +50,64 @@ module RubyLLM
         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"],
+          default: param_data["default"]
+        )
+
+        if param.type == :array
+          items = param_data["items"]
+          param.items = items
+          if items.key?("properties")
+            param.properties = create_parameters(items)
+          end
+          if items.key?("enum")
+            param.enum = items["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["content"], content["mime_type"])
+          attachment = MCP::Attachment.new(content["data"], content["mimeType"])
           MCP::Content.new(text: nil, attachments: [attachment])
         when "resource"
-          resource = Resource.new(mcp_client, content["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