ruby_llm-mcp 0.2.1 → 0.3.0

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

@@ -10,21 +10,35 @@ 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,
+                               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

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/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, :mcp_client
 
-      def initialize(mcp_client, resource, template: false)
+      def initialize(mcp_client, resource)
         @mcp_client = mcp_client
         @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,35 +34,30 @@ 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
@@ -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, :mcp_client, :template
+
+      def initialize(mcp_client, resource)
+        @mcp_client = mcp_client
+        @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(mcp_client, {
+                       "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 @mcp_client.capabilities.completion?
+          response = @mcp_client.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://
+          @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_s] ||
+            arguments[::Regexp.last_match(1).to_sym] ||
+            "{#{::Regexp.last_match(1)}}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -10,7 +10,7 @@ module RubyLLM
         @mcp_client = mcp_client
 
         @name = tool_response["name"]
-        @description = tool_response["description"]
+        @description = tool_response["description"].to_s
         @parameters = create_parameters(tool_response["inputSchema"])
       end
 
@@ -21,10 +21,11 @@ module RubyLLM
         )
 
         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,63 @@ 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"]
+        )
+
+        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["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(mcp_client, resource_data)
           resource.to_content
         end
       end

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

@@ -40,8 +40,7 @@ module RubyLLM
           start_sse_listener
         end
 
-        # rubocop:disable Metrics/MethodLength
-        def request(body, add_id: true, wait_for_response: true)
+        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 }
@@ -60,7 +59,7 @@ module RubyLLM
           # Send the request using Faraday
           begin
             conn = Faraday.new do |f|
-              f.options.timeout = 30
+              f.options.timeout = @request_timeout / 1000
               f.options.open_timeout = 5
             end
 
@@ -83,15 +82,20 @@ module RubyLLM
           return unless wait_for_response
 
           begin
-            Timeout.timeout(30) do
+            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 30 seconds")
+            raise RubyLLM::MCP::Errors::TimeoutError.new(
+              message: "Request timed out after #{@request_timeout / 1000} seconds"
+            )
           end
         end
-        # rubocop:enable Metrics/MethodLength
+
+        def alive?
+          @running
+        end
 
         def close
           @running = false

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

@@ -11,7 +11,8 @@ module RubyLLM
       class Stdio
         attr_reader :command, :stdin, :stdout, :stderr, :id
 
-        def initialize(command, args: [], env: {})
+        def initialize(command, request_timeout:, args: [], env: {})
+          @request_timeout = request_timeout
           @command = command
           @args = args
           @env = env || {}
@@ -23,6 +24,7 @@ module RubyLLM
           @pending_mutex = Mutex.new
           @running = true
           @reader_thread = nil
+          @stderr_thread = nil
 
           start_process
         end
@@ -53,16 +55,22 @@ module RubyLLM
           return unless wait_for_response
 
           begin
-            Timeout.timeout(30) do
+            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 30 seconds")
+            raise RubyLLM::MCP::Errors::TimeoutError.new(
+              message: "Request timed out after #{@request_timeout / 1000} seconds"
+            )
           end
         end
 
-        def close
+        def alive?
+          @running
+        end
+
+        def close # rubocop:disable Metrics/MethodLength
           @running = false
 
           begin
@@ -82,6 +90,7 @@ module RubyLLM
           rescue StandardError
             nil
           end
+
           begin
             @stderr&.close
           rescue StandardError
@@ -94,11 +103,18 @@ module RubyLLM
             nil
           end
 
+          begin
+            @stderr_thread&.join(1)
+          rescue StandardError
+            nil
+          end
+
           @stdin = nil
           @stdout = nil
           @stderr = nil
           @wait_thread = nil
           @reader_thread = nil
+          @stderr_thread = nil
         end
 
         private
@@ -109,10 +125,11 @@ module RubyLLM
           @stdin, @stdout, @stderr, @wait_thread = if @env.empty?
                                                      Open3.popen3(@command, *@args)
                                                    else
-                                                     Open3.popen3(environment_string, @command, *@args)
+                                                     Open3.popen3(@env, @command, *@args)
                                                    end
 
           start_reader_thread
+          start_stderr_thread
         end
 
         def restart_process
@@ -148,12 +165,34 @@ module RubyLLM
           @reader_thread.abort_on_exception = true
         end
 
-        def process_response(line)
-          response = begin
-            JSON.parse(line)
-          rescue JSON::ParserError => e
-            raise "Error parsing response as JSON: #{e.message}\nRaw response: #{line}"
+        def start_stderr_thread
+          @stderr_thread = Thread.new do
+            while @running
+              begin
+                if @stderr.closed? || @wait_thread.nil? || !@wait_thread.alive?
+                  sleep 1
+                  next
+                end
+
+                line = @stderr.gets
+                next unless line && !line.strip.empty?
+
+                puts "STDERR: #{line.strip}"
+              rescue IOError, Errno::EPIPE => e
+                puts "Stderr reader error: #{e.message}"
+                sleep 1
+              rescue StandardError => e
+                puts "Error in stderr thread: #{e.message}"
+                sleep 1
+              end
+            end
           end
+
+          @stderr_thread.abort_on_exception = true
+        end
+
+        def process_response(line)
+          response = JSON.parse(line)
           request_id = response["id"]&.to_s
 
           @pending_mutex.synchronize do
@@ -162,10 +201,8 @@ module RubyLLM
               response_queue&.push(response)
             end
           end
-        end
-
-        def environment_string
-          @env.map { |key, value| "#{key}=#{value}" }.join(" ")
+        rescue JSON::ParserError => e
+          RubyLLM.logger.error("Error parsing response as JSON: #{e.message}\nRaw response: #{line}")
         end
       end
     end

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

@@ -12,8 +12,9 @@ module RubyLLM
       class Streamable
         attr_reader :headers, :id, :session_id
 
-        def initialize(url, headers: {})
+        def initialize(url, request_timeout:, headers: {})
           @url = url
+          @request_timeout = request_timeout
           @client_id = SecureRandom.uuid
           @session_id = nil
           @base_headers = headers.merge({
@@ -55,6 +56,10 @@ module RubyLLM
           handle_response(response, request_id, response_queue, wait_for_response)
         end
 
+        def alive?
+          @running
+        end
+
         def close
           @running = false
           @sse_mutex.synchronize do
@@ -83,7 +88,7 @@ module RubyLLM
 
         def create_connection
           Faraday.new(url: @url) do |f|
-            f.options.timeout = 300
+            f.options.timeout = @request_timeout / 1000
             f.options.open_timeout = 10
           end
         end
@@ -279,12 +284,14 @@ module RubyLLM
         end
 
         def wait_for_response_with_timeout(request_id, response_queue)
-          Timeout.timeout(30) do
+          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 30 seconds")
+          raise RubyLLM::MCP::Errors::TimeoutError.new(
+            message: "Request timed out after #{@request_timeout / 1000} seconds"
+          )
         end
       end
     end

data/lib/ruby_llm/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end