ruby_llm-mcp 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6cf22dd6e681b51686e73f0149f91b0fd3a256ccbba1e3dd20461d0a92b370d
-  data.tar.gz: 8ed938f20b001c4879a409ab77944e6d8b5e53aa0062d6e499d3739355c5054d
+  metadata.gz: 49b1593de3f38afce9d3002a696c7034c2bea82711742ea4bd96a5f155f113e3
+  data.tar.gz: 6fb3c4b87bc82684bb9ef093b70b13eea91e759f5ee44a08b4be543cc45d30d3
 SHA512:
-  metadata.gz: 817fa242ef9d4cd526ea8905093d6c548f36ffeb228ee3b0acfbb0fd80303ec69557493e9b0ee0b2419c0d5adddf79c2bda02ba577e7e90a0503fd9482444bc5
-  data.tar.gz: '09326061dfcdc66d963ef55740ad4d0d82c260ed1da6021229d6441c9c8f1c17af744fd90d9e865e9ddc209589f663c8c5a94aea020ca7bc189c41b668d58433'
+  metadata.gz: 6950867fde16315dba705049ec2d23cc89f3977808d323af20b5bf343b2453228145190e183bfd6350b95df856ae96bf4f60a83145eb0137dad0003454c889d3
+  data.tar.gz: 1ed01c5ec46651c1b420971a429299e60b59707255403f1a167c8832cfde9ee5ba1a5ed00ba1edea8f2bf710006f1d605896781c329f02f5ca056642fe246100

data/README.md

@@ -2,16 +2,19 @@
 
 Aiming to make using MCP with RubyLLM as easy as possible.
 
-This project is a Ruby client for the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/), designed to work seamlessly with [RubyLLM](https://github.com/patvice/ruby_llm). This gem enables Ruby applications to connect to MCP servers and use their tools as part of LLM conversations.
+This project is a Ruby client for the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/), designed to work seamlessly with [RubyLLM](https://github.com/crmne/ruby_llm). This gem enables Ruby applications to connect to MCP servers and use their tools, resources and prompts as part of LLM conversations.
 
-**Note:** This project is still under development and the API is subject to change. Currently supports the connecting workflow, tool lists and tool execution.
+**Note:** This project is still under development and the API is subject to change.
 
 ## Features
 
 - 🔌 **Multiple Transport Types**: Support for SSE (Server-Sent Events), Streamable HTTP, and stdio transports
 - 🛠️ **Tool Integration**: Automatically converts MCP tools into RubyLLM-compatible tools
+- 📄 **Resource Management**: Access and include MCP resources (files, data) and resource templates in conversations
+- 🎯 **Prompt Integration**: Use predefined MCP prompts with arguments for consistent interactions
 - 🔄 **Real-time Communication**: Efficient bidirectional communication with MCP servers
-- 🎯 **Simple API**: Easy-to-use interface that integrates seamlessly with RubyLLM
+- 🎨 **Enhanced Chat Interface**: Extended RubyLLM chat methods for seamless MCP integration
+- 📚 **Simple API**: Easy-to-use interface that integrates seamlessly with RubyLLM
 
 ## Installation
 
@@ -50,7 +53,7 @@ end
 # Connect to an MCP server via SSE
 client = RubyLLM::MCP.client(
   name: "my-mcp-server",
-  transport_type: "sse",
+  transport_type: :sse,
   config: {
     url: "http://localhost:9292/mcp/sse"
   }
@@ -59,7 +62,7 @@ client = RubyLLM::MCP.client(
 # Or connect via stdio
 client = RubyLLM::MCP.client(
   name: "my-mcp-server",
-  transport_type: "stdio",
+  transport_type: :stdio,
   config: {
     command: "node",
     args: ["path/to/mcp-server.js"],
@@ -70,7 +73,7 @@ client = RubyLLM::MCP.client(
 # Or connect via streamable HTTP
 client = RubyLLM::MCP.client(
   name: "my-mcp-server",
-  transport_type: :streamable",
+  transport_type: :streamable,
   config: {
     url: "http://localhost:8080/mcp",
     headers: { "Authorization" => "Bearer your-token" }
@@ -139,6 +142,142 @@ result = client.execute_tool(
 puts result
 ```
 
+### Working with Resources
+
+MCP servers can provide access to resources - structured data that can be included in conversations. Resources come in two types: normal resources and resource templates.
+
+#### Normal Resources
+
+```ruby
+# Get available resources from the MCP server
+resources = client.resources
+puts "Available resources:"
+resources.each do |name, resource|
+  puts "- #{name}: #{resource.description}"
+end
+
+# Access a specific resource
+file_resource = resources["project_readme"]
+content = file_resource.content
+puts "Resource content: #{content}"
+
+# Include a resource in a chat conversation for reference with an LLM
+chat = RubyLLM.chat(model: "gpt-4")
+chat.with_resource(file_resource)
+
+# Or add a resource directly to the conversation
+file_resource.include(chat)
+
+response = chat.ask("Can you summarize this README file?")
+puts response
+```
+
+#### Resource Templates
+
+Resource templates are parameterized resources that can be dynamically configured:
+
+```ruby
+# Get available resource templates
+templates = client.resource_templates
+log_template = templates["application_logs"]
+
+# Use a template with parameters
+chat = RubyLLM.chat(model: "gpt-4")
+chat.with_resource(log_template, arguments: {
+  date: "2024-01-15",
+  level: "error"
+})
+
+response = chat.ask("What errors occurred on this date?")
+puts response
+
+# You can also get templated content directly
+content = log_template.content(arguments: {
+  date: "2024-01-15",
+  level: "error"
+})
+puts content
+```
+
+#### Resource Argument Completion
+
+For resource templates, you can get suggested values for arguments:
+
+```ruby
+template = client.resource_templates["user_profile"]
+
+# Search for possible values for a specific argument
+suggestions = template.arguments_search("username", "john")
+puts "Suggested usernames:"
+suggestions.arg_values.each do |value|
+  puts "- #{value}"
+end
+puts "Total matches: #{suggestions.total}"
+puts "Has more: #{suggestions.has_more}"
+```
+
+### Working with Prompts
+
+MCP servers can provide predefined prompts that can be used in conversations:
+
+```ruby
+# Get available prompts from the MCP server
+prompts = client.prompts
+puts "Available prompts:"
+prompts.each do |name, prompt|
+  puts "- #{name}: #{prompt.description}"
+  prompt.arguments.each do |arg|
+    puts "  - #{arg.name}: #{arg.description} (required: #{arg.required})"
+  end
+end
+
+# Use a prompt in a conversation
+greeting_prompt = prompts["daily_greeting"]
+chat = RubyLLM.chat(model: "gpt-4")
+
+# Method 1: Ask prompt directly
+response = chat.ask_prompt(greeting_prompt, arguments: { name: "Alice", time: "morning" })
+puts response
+
+# Method 2: Add prompt to chat and then ask
+chat.with_prompt(greeting_prompt, arguments: { name: "Alice", time: "morning" })
+response = chat.ask("Continue with the greeting")
+```
+
+### Combining Resources, Prompts, and Tools
+
+You can combine all MCP features for powerful conversations:
+
+```ruby
+client = RubyLLM::MCP.client(
+  name: "development-assistant",
+  transport_type: :sse,
+  config: { url: "http://localhost:9292/mcp/sse" }
+)
+
+chat = RubyLLM.chat(model: "gpt-4")
+
+# Add tools for capabilities
+chat.with_tools(*client.tools)
+
+# Add resources for context
+chat.with_resource(client.resources["project_structure"])
+chat.with_resource(
+  client.resource_templates["recent_commits"],
+  arguments: { days: 7 }
+)
+
+# Add prompts for guidance
+chat.with_prompt(
+  client.prompts["code_review_checklist"],
+  arguments: { focus: "security" }
+)
+
+# Now ask for analysis
+response = chat.ask("Please review the recent commits using the checklist and suggest improvements")
+puts response
+```
+
 ## Transport Types
 
 ### SSE (Server-Sent Events)

data/lib/ruby_llm/chat.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# This is an override of the RubyLLM::Chat class to convient methods for easy MCP support
+module RubyLLM
+  class Chat
+    def with_resources(*resources, **args)
+      resources.each do |resource|
+        resource.include(self, **args)
+      end
+      self
+    end
+
+    def with_resource(resource, **args)
+      resource.include(self, **args)
+      self
+    end
+
+    def with_prompt(prompt, arguments: {})
+      prompt.include(self, arguments: arguments)
+      self
+    end
+
+    def ask_prompt(prompt, ...)
+      prompt.ask(self, ...)
+    end
+  end
+end

data/lib/ruby_llm/mcp/attachment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Attachment < RubyLLM::Attachment
+      attr_reader :content, :mime_type
+
+      def initialize(content, mime_type) # rubocop:disable Lint/MissingSuper
+        @content = content
+        @mime_type = mime_type
+      end
+
+      def encoded
+        @content
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/client.rb

@@ -55,13 +55,13 @@ module RubyLLM
         @resource_templates ||= fetch_and_create_resources(set_as_template: true)
       end
 
-      def execute_tool(name:, parameters:)
-        response = execute_tool_request(name: name, parameters: parameters)
-        result = response["result"]
-        # TODO: handle tool error when "isError" is true in result
-        #
-        # TODO: Implement "type": "image" and "type": "resource"
-        result["content"].map { |content| content["text"] }.join("\n")
+      def prompts(refresh: false)
+        @prompts = nil if refresh
+        @prompts ||= fetch_and_create_prompts
+      end
+
+      def execute_tool(**args)
+        RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
       end
 
       def resource_read_request(**args)
@@ -72,6 +72,10 @@ module RubyLLM
         RubyLLM::MCP::Requests::Completion.new(self, **args).call
       end
 
+      def execute_prompt(**args)
+        RubyLLM::MCP::Requests::PromptCall.new(self, **args).call
+      end
+
       private
 
       def initialize_request
@@ -87,10 +91,6 @@ module RubyLLM
         RubyLLM::MCP::Requests::ToolList.new(self).call
       end
 
-      def execute_tool_request(**args)
-        RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
-      end
-
       def resources_list_request
         RubyLLM::MCP::Requests::ResourceList.new(self).call
       end
@@ -99,6 +99,10 @@ module RubyLLM
         RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
       end
 
+      def prompt_list_request
+        RubyLLM::MCP::Requests::PromptList.new(self).call
+      end
+
       def fetch_and_create_tools
         tools_response = tool_list_request
         tools_response = tools_response["result"]["tools"]
@@ -112,9 +116,30 @@ module RubyLLM
         resources_response = resources_list_request
         resources_response = resources_response["result"]["resources"]
 
-        @resources = resources_response.map do |resource|
-          RubyLLM::MCP::Resource.new(self, resource, template: set_as_template)
+        resources = {}
+        resources_response.each do |resource|
+          new_resource = RubyLLM::MCP::Resource.new(self, resource, template: set_as_template)
+          resources[new_resource.name] = new_resource
+        end
+
+        resources
+      end
+
+      def fetch_and_create_prompts
+        prompts_response = prompt_list_request
+        prompts_response = prompts_response["result"]["prompts"]
+
+        prompts = {}
+        prompts_response.each do |prompt|
+          new_prompt = RubyLLM::MCP::Prompt.new(self,
+                                                name: prompt["name"],
+                                                description: prompt["description"],
+                                                arguments: prompt["arguments"])
+
+          prompts[new_prompt.name] = new_prompt
         end
+
+        prompts
       end
     end
   end

data/lib/ruby_llm/mcp/completion.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Completion
+      attr_reader :values, :total, :has_more
+
+      def initialize(values:, total:, has_more:)
+        @values = values
+        @total = total
+        @has_more = has_more
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/content.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Content < RubyLLM::Content
+      attr_reader :text, :attachments, :content
+
+      def initialize(text: nil, attachments: nil) # rubocop:disable Lint/MissingSuper
+        @text = text
+        @attachments = attachments || []
+      end
+
+      # This is a workaround to allow the content object to be passed as the tool call
+      # to return audio or image attachments.
+      def to_s
+        attachments.empty? ? text : self
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/errors.rb

@@ -17,6 +17,10 @@ module RubyLLM
       class SessionExpiredError < BaseError; end
 
       class TimeoutError < BaseError; end
+
+      class PromptArgumentError < BaseError; end
+
+      class CompletionNotAvailable < BaseError; end
     end
   end
 end

data/lib/ruby_llm/mcp/prompt.rb

@@ -0,0 +1,95 @@
+# 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, :mcp_client
+
+      def initialize(mcp_client, name:, description:, arguments:)
+        @mcp_client = mcp_client
+        @name = name
+        @description = description
+
+        @arguments = arguments.map do |arg|
+          Argument.new(name: arg["name"], description: arg["description"], required: arg["required"])
+        end
+      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 arguments_search(argument, value)
+        if @mcp_client.capabilities.completion?
+          response = @mcp_client.completion(type: :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"
+        end
+      end
+
+      private
+
+      def fetch_prompt_messages(arguments)
+        response = @mcp_client.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(mcp_client, content["resource"])
+          resource.to_content
+        end
+      end
+    end
+  end
+end

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/openai/complex_parameter_support.rb

@@ -0,0 +1,38 @@
+# 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
+                           {
+                             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
+
+            properties.compact
+          end
+        end
+      end
+    end
+  end
+end
+
+RubyLLM::Providers::OpenAI.extend(RubyLLM::MCP::Providers::OpenAI::ComplexParameterSupport)

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/resource.rb

@@ -11,20 +11,50 @@ module RubyLLM
         @name = resource["name"]
         @description = resource["description"]
         @mime_type = resource["mimeType"]
+        @content = resource["content"] || nil
         @template = template
       end
 
-      def content(parsable_information: {})
+      def content(arguments: {})
+        return @content if @content && !template?
+
         response = if template?
-                     templated_uri = apply_template(@uri, parsable_information)
+                     templated_uri = apply_template(@uri, arguments)
 
                      read_response(uri: templated_uri)
                    else
                      read_response
                    end
 
-        response.dig("result", "contents", 0, "text") ||
-          response.dig("result", "contents", 0, "blob")
+        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)
@@ -32,10 +62,9 @@ module RubyLLM
           response = @mcp_client.completion(type: :resource, name: @name, argument: argument, value: value)
           response = response.dig("result", "completion")
 
-          Struct.new(:arg_values, :total, :has_more)
-                .new(response["values"], response["total"], response["hasMore"])
+          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
 
@@ -60,9 +89,9 @@ module RubyLLM
         { "result" => { "contents" => [{ "text" => response.body }] } }
       end
 
-      def apply_template(uri, parsable_information)
+      def apply_template(uri, arguments)
         uri.gsub(/\{(\w+)\}/) do
-          parsable_information[::Regexp.last_match(1).to_sym] || "{#{::Regexp.last_match(1)}}"
+          arguments[::Regexp.last_match(1).to_sym] || "{#{::Regexp.last_match(1)}}"
         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/version.rb

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

data/lib/ruby_llm/mcp.rb

@@ -2,10 +2,12 @@
 
 require "ruby_llm"
 require "zeitwerk"
+require_relative "chat"
 
 loader = Zeitwerk::Loader.for_gem_extension(RubyLLM)
 loader.inflector.inflect("mcp" => "MCP")
 loader.inflector.inflect("sse" => "SSE")
+loader.inflector.inflect("openai" => "OpenAI")
 loader.setup
 
 module RubyLLM
@@ -17,8 +19,9 @@ module RubyLLM
     end
 
     def support_complex_parameters!
-      require_relative "mcp/providers/open_ai/complex_parameter_support"
+      require_relative "mcp/providers/openai/complex_parameter_support"
       require_relative "mcp/providers/anthropic/complex_parameter_support"
+      require_relative "mcp/providers/gemini/complex_parameter_support"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Patrick Vice
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-11 00:00:00.000000000 Z
+date: 2025-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -107,17 +107,24 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/ruby_llm/chat.rb
 - lib/ruby_llm/mcp.rb
+- lib/ruby_llm/mcp/attachment.rb
 - lib/ruby_llm/mcp/capabilities.rb
 - lib/ruby_llm/mcp/client.rb
+- lib/ruby_llm/mcp/completion.rb
+- lib/ruby_llm/mcp/content.rb
 - lib/ruby_llm/mcp/errors.rb
 - lib/ruby_llm/mcp/parameter.rb
+- lib/ruby_llm/mcp/prompt.rb
 - lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb
-- lib/ruby_llm/mcp/providers/open_ai/complex_parameter_support.rb
+- lib/ruby_llm/mcp/providers/openai/complex_parameter_support.rb
 - lib/ruby_llm/mcp/requests/base.rb
 - lib/ruby_llm/mcp/requests/completion.rb
 - lib/ruby_llm/mcp/requests/initialization.rb
 - lib/ruby_llm/mcp/requests/notification.rb
+- lib/ruby_llm/mcp/requests/prompt_call.rb
+- lib/ruby_llm/mcp/requests/prompt_list.rb
 - lib/ruby_llm/mcp/requests/resource_list.rb
 - lib/ruby_llm/mcp/requests/resource_read.rb
 - lib/ruby_llm/mcp/requests/resource_template_list.rb
@@ -148,14 +155,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.1.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A RubyLLM MCP Client

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Providers
-      module OpenAI
-        module ComplexParameterSupport
-          def param_schema(param)
-            format = {
-              type: param.type,
-              description: param.description
-            }.compact
-
-            if param.type == "array"
-              format[:items] = param.items
-            elsif param.type == "object"
-              format[:properties] = param.properties.transform_values { |value| param_schema(value) }
-            end
-            format
-          end
-        end
-      end
-    end
-  end
-end
-
-RubyLLM::Providers::OpenAI.extend(RubyLLM::MCP::Providers::OpenAI::ComplexParameterSupport)