model-context-protocol-rb 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa9e49b895a1502fe4887f7e2089c24b69b980d9ac7c27754f97c52ad1541c7b
-  data.tar.gz: 92e343e66c69cd1e5ae9f9d8adb83567303a2aa5e48021b1dc964c172128426d
+  metadata.gz: 99ee11ebae0c9c984a15954b386e89489f6715a1d371b288ece0438d066436d7
+  data.tar.gz: cdf41e8742941e9a0a41c714127d02f5a189d901a95a35e6f61a16f1f7b8a704
 SHA512:
-  metadata.gz: bcbfcb95e17f7e0deaa368f7e2b3dc7915be124b4c98b2b86b8e94c446fe18bd7d9e8c7dbfb6e4301edf6b1ad28e491701fec85bbd31dcd2d79d8b91a3f0c8c1
-  data.tar.gz: 284e545287ecacb83d42c7a5f72dbe9b0f5ab359d50c9d0cfcde1eb2e00d9c330e9cce3b6bcb15e68fb48963e8778888ca3dbdf1fab5ac0a0d27d36f1ca4e6bd
+  metadata.gz: aad64bd6e42b2ecea2b742bb23b902ea1bfae3e77cffc5009b0a83712df7efac417b680bb460649bb73fff31d2d554d33a17d6fe96adb35f3cc9d0addbbcf9be
+  data.tar.gz: 6fa834a1c2bf4494748474dc26a29bede650b1a1913c7c543a7c195fd24fe99eda5f1610c40a63067f454b50f669b1fb47030e106fa6ba80cbde522bccfb9518

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.3.2] - 2025-05-10
+
+- Added resource template support.
+- Added completion support for prompts and resources.
+- Improved metadata definition for prompts, resources, and tools using simple DSL.
+
 ## [0.3.1] - 2025-04-04
 
 - Added support for environment variables to MCP servers (thanks @hmk):
@@ -31,7 +37,8 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.2...HEAD
+[0.3.1]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.1.0...v0.2.0

data/README.md

@@ -8,13 +8,10 @@ You are welcome to contribute.
 
 TODO's:
 
-* [Completion](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/utilities/completion/)
-* [Logging](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/utilities/logging/)
 * [Pagination](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/utilities/pagination/)
 * [Prompt list changed notifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/prompts/#list-changed-notification)
 * [Resource list changed notifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/#list-changed-notification)
 * [Resource subscriptions](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/#subscriptions)
-* [Resource templates](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/#resource-templates)
 * [Tool list changed notifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/tools/#list-changed-notification)
 
 ## Usage
@@ -27,7 +24,7 @@ require 'model_context_protocol'
 
 ### Building an MCP Server
 
-Build a simple MCP server by registering your prompts, resources, and tools. Then, configure and run the server.
+Build a simple MCP server by registering your prompts, resources, resource templates, and tools. Then, configure and run the server.
 
 ```ruby
 server = ModelContextProtocol::Server.new do |config|
@@ -51,6 +48,10 @@ server = ModelContextProtocol::Server.new do |config|
       register TestResource
     end
 
+    resource_templates do
+      register TestResourceTemplate
+    end
+
     tools list_changed: true do
       register TestTool
     end
@@ -62,10 +63,12 @@ server.start
 
 Messages from the MCP client will be routed to the appropriate custom handler. This SDK provides several classes that should be used to build your handlers.
 
-#### ModelContextProtocol::Server::Prompt
+#### Prompts
 
 The `ModelContextProtocol::Server::Prompt` base class allows subclasses to define a prompt that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/prompts/) in the `with_metadata` block.
 
+Define any arguments using the `with_argument` block. You can mark an argument as required, and you can optionally provide the class name of a service object that provides completions. See [Completions](#completions) for more information.
+
 Then implement the `call` method to build your prompt. Use the `respond_with` instance method to ensure your prompt responds with appropriately formatted response data.
 
 This is an example prompt that returns a properly formatted response:
@@ -73,22 +76,21 @@ This is an example prompt that returns a properly formatted response:
 ```ruby
 class TestPrompt < ModelContextProtocol::Server::Prompt
   with_metadata do
-    {
-      name: "Test Prompt",
-      description: "A test prompt",
-      arguments: [
-        {
-          name: "message",
-          description: "The thing to do",
-          required: true
-        },
-        {
-          name: "other",
-          description: "Another thing to do",
-          required: false
-        }
-      ]
-    }
+    name "test_prompt"
+    description "A test prompt"
+  end
+
+  with_argument do
+    name "message"
+    description "The thing to do"
+    required true
+    completion TestCompletion
+  end
+
+  with_argument do
+    name "other"
+    description "Another thing to do"
+    required false
   end
 
   def call
@@ -107,7 +109,7 @@ class TestPrompt < ModelContextProtocol::Server::Prompt
 end
 ```
 
-#### ModelContextProtocol::Server::Resource
+#### Resources
 
 The `ModelContextProtocol::Server::Resource` base class allows subclasses to define a resource that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/resources/) in the `with_metadata` block.
 
@@ -118,12 +120,10 @@ This is an example resource that returns a text response:
 ```ruby
 class TestResource < ModelContextProtocol::Server::Resource
   with_metadata do
-    {
-      name: "Test Resource",
-      description: "A test resource",
-      mime_type: "text/plain",
-      uri: "resource://test-resource"
-    }
+    name "Test Resource"
+    description "A test resource"
+    mime_type "text/plain"
+    uri "resource://test-resource"
   end
 
   def call
@@ -137,12 +137,10 @@ This is an example resource that returns binary data:
 ```ruby
 class TestBinaryResource < ModelContextProtocol::Server::Resource
   with_metadata do
-    {
-      name: "Project Logo",
-      description: "The logo for the project",
-      mime_type: "image/jpeg",
-      uri: "resource://project-logo"
-    }
+    name "Project Logo"
+    description "The logo for the project"
+    mime_type "image/jpeg"
+    uri "resource://project-logo"
   end
 
   def call
@@ -153,7 +151,37 @@ class TestBinaryResource < ModelContextProtocol::Server::Resource
 end
 ```
 
-#### ModelContextProtocol::Server::Tool
+#### Resource Templates
+
+The `ModelContextProtocol::Server::ResourceTemplate` base class allows subclasses to define a resource template that the MCP client can use. Define the [appropriate metadata](https://modelcontextprotocol.io/specification/2024-11-05/server/resources#resource-templates) in the `with_metadata` block.
+
+This is an example resource template that provides a completion for a parameter of the URI template:
+
+```ruby
+class TestResourceTemplateCompletion < ModelContextProtocol::Server::Completion
+  def call
+    hints = {
+      "name" => ["test-resource", "project-logo"]
+    }
+    values = hints[argument_name].grep(/#{argument_value}/)
+
+    respond_with values:
+  end
+end
+
+class TestResourceTemplate < ModelContextProtocol::Server::ResourceTemplate
+  with_metadata do
+    name "Test Resource Template"
+    description "A test resource template"
+    mime_type "text/plain"
+    uri_template "resource://{name}" do
+      completion :name, TestResourceTemplateCompletion
+    end
+  end
+end
+```
+
+#### Tools
 
 The `ModelContextProtocol::Server::Tool` base class allows subclasses to define a tool that the MCP client can use. Define the [appropriate metadata](https://spec.modelcontextprotocol.io/specification/2024-11-05/server/tools/) in the `with_metadata` block.
 
@@ -164,19 +192,19 @@ This is an example tool that returns a text response:
 ```ruby
 class TestToolWithTextResponse < ModelContextProtocol::Server::Tool
   with_metadata do
-    {
-      name: "double",
-      description: "Doubles the provided number",
-      inputSchema: {
+    name "double"
+    description "Doubles the provided number"
+    input_schema do
+      {
         type: "object",
         properties: {
           number: {
-            type: "string",
+            type: "string"
           }
         },
         required: ["number"]
       }
-    }
+    end
   end
 
   def call
@@ -192,10 +220,10 @@ This is an example of a tool that returns an image:
 ```ruby
 class TestToolWithImageResponse < ModelContextProtocol::Server::Tool
   with_metadata do
-    {
-      name: "custom-chart-generator",
-      description: "Generates a chart in various formats",
-      inputSchema: {
+    name "custom-chart-generator"
+    description "Generates a chart in various formats"
+    input_schema do
+      {
         type: "object",
         properties: {
           chart_type: {
@@ -209,7 +237,7 @@ class TestToolWithImageResponse < ModelContextProtocol::Server::Tool
         },
         required: ["chart_type", "format"]
       }
-    }
+    end
   end
 
   def call
@@ -236,10 +264,10 @@ If you don't provide a mime type, it will default to `image/png`.
 ```ruby
 class TestToolWithImageResponseDefaultMimeType < ModelContextProtocol::Server::Tool
   with_metadata do
-    {
-      name: "other-custom-chart-generator",
-      description: "Generates a chart",
-      inputSchema: {
+    name "other-custom-chart-generator"
+    description "Generates a chart"
+    input_schema do
+      {
         type: "object",
         properties: {
           chart_type: {
@@ -249,7 +277,7 @@ class TestToolWithImageResponseDefaultMimeType < ModelContextProtocol::Server::T
         },
         required: ["chart_type"]
       }
-    }
+    end
   end
 
   def call
@@ -266,10 +294,10 @@ This is an example of a tool that returns a resource response:
 ```ruby
 class TestToolWithResourceResponse < ModelContextProtocol::Server::Tool
   with_metadata do
-    {
-      name: "document-finder",
-      description: "Finds a the document with the given title",
-      inputSchema: {
+    name "document-finder"
+    description "Finds a the document with the given title"
+    input_schema do
+      {
         type: "object",
         properties: {
           title: {
@@ -279,7 +307,7 @@ class TestToolWithResourceResponse < ModelContextProtocol::Server::Tool
         },
         required: ["title"]
       }
-    }
+    end
   end
 
   def call
@@ -291,6 +319,27 @@ class TestToolWithResourceResponse < ModelContextProtocol::Server::Tool
 end
 ```
 
+### Completions
+
+The `ModelContextProtocol::Server::Completion` base class allows subclasses to define a completion that the MCP client can use to obtain hints or suggestions for arguments to prompts and resources.
+
+implement the `call` method to build your completion. Use the `respond_with` instance method to ensure your completion responds with appropriately formatted response data.
+
+This is an example completion that returns an array of values in the response:
+
+```ruby
+class TestCompletion < ModelContextProtocol::Server::Completion
+  def call
+    hints = {
+      "message" => ["hello", "world", "foo", "bar"]
+    }
+    values = hints[argument_name].grep(/#{argument_value}/)
+
+    respond_with values:
+  end
+end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/model_context_protocol/server/completion.rb

@@ -0,0 +1,45 @@
+module ModelContextProtocol
+  class Server::Completion
+    attr_reader :argument_name, :argument_value
+
+    def initialize(argument_name, argument_value)
+      @argument_name = argument_name
+      @argument_value = argument_value
+    end
+
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+    end
+
+    def self.call(...)
+      new(...).call
+    end
+
+    private
+
+    Response = Data.define(:values, :total, :hasMore) do
+      def serialized
+        {completion: {values:, total:, hasMore:}}
+      end
+    end
+
+    def respond_with(values:)
+      values_to_return = values.take(100)
+      total = values.size
+      has_more = values_to_return.size != total
+      Response[values:, total:, hasMore: has_more]
+    end
+  end
+
+  class Server::NullCompletion
+    Response = Data.define(:values, :total, :hasMore) do
+      def serialized
+        {completion: {values:, total:, hasMore:}}
+      end
+    end
+
+    def self.call(_argument_name, _argument_value)
+      Response[values: [], total: 0, hasMore: false]
+    end
+  end
+end

data/lib/model_context_protocol/server/prompt.rb

@@ -1,10 +1,9 @@
 module ModelContextProtocol
   class Server::Prompt
-    attr_reader :params, :description
+    attr_reader :params
 
     def initialize(params)
       validate!(params)
-      @description = self.class.description
       @params = params
     end
 
@@ -12,15 +11,15 @@ module ModelContextProtocol
       raise NotImplementedError, "Subclasses must implement the call method"
     end
 
-    Response = Data.define(:messages, :prompt) do
+    Response = Data.define(:messages, :description) do
       def serialized
-        {description: prompt.description, messages:}
+        {description:, messages:}
       end
     end
     private_constant :Response
 
     private def respond_with(messages:)
-      Response[messages:, prompt: self]
+      Response[messages:, description: self.class.description]
     end
 
     private def validate!(params = {})
@@ -45,17 +44,33 @@ module ModelContextProtocol
       attr_reader :name, :description, :arguments
 
       def with_metadata(&block)
-        metadata = instance_eval(&block)
+        @arguments ||= []
 
-        @name = metadata[:name]
-        @description = metadata[:description]
-        @arguments = metadata[:arguments]
+        metadata_dsl = MetadataDSL.new
+        metadata_dsl.instance_eval(&block)
+
+        @name = metadata_dsl.name
+        @description = metadata_dsl.description
+      end
+
+      def with_argument(&block)
+        @arguments ||= []
+
+        argument_dsl = ArgumentDSL.new
+        argument_dsl.instance_eval(&block)
+
+        @arguments << {
+          name: argument_dsl.name,
+          description: argument_dsl.description,
+          required: argument_dsl.required,
+          completion: argument_dsl.completion
+        }
       end
 
       def inherited(subclass)
         subclass.instance_variable_set(:@name, @name)
         subclass.instance_variable_set(:@description, @description)
-        subclass.instance_variable_set(:@arguments, @arguments)
+        subclass.instance_variable_set(:@arguments, @arguments&.dup)
       end
 
       def call(params)
@@ -67,6 +82,46 @@ module ModelContextProtocol
       def metadata
         {name: @name, description: @description, arguments: @arguments}
       end
+
+      def complete_for(arg_name, value)
+        arg = @arguments&.find { |a| a[:name] == arg_name.to_s }
+        completion = (arg && arg[:completion]) ? arg[:completion] : ModelContextProtocol::Server::NullCompletion
+        completion.call(arg_name.to_s, value)
+      end
+    end
+
+    class MetadataDSL
+      def name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def description(value = nil)
+        @description = value if value
+        @description
+      end
+    end
+
+    class ArgumentDSL
+      def name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def description(value = nil)
+        @description = value if value
+        @description
+      end
+
+      def required(value = nil)
+        @required = value unless value.nil?
+        @required
+      end
+
+      def completion(klass = nil)
+        @completion = klass unless klass.nil?
+        @completion
+      end
     end
   end
 end

data/lib/model_context_protocol/server/registry.rb

@@ -12,6 +12,7 @@ module ModelContextProtocol
     def initialize
       @prompts = []
       @resources = []
+      @resource_templates = []
       @tools = []
       @prompts_options = {}
       @resources_options = {}
@@ -28,6 +29,10 @@ module ModelContextProtocol
       instance_eval(&block) if block
     end
 
+    def resource_templates(&block)
+      instance_eval(&block) if block
+    end
+
     def tools(options = {}, &block)
       @tools_options = options
       instance_eval(&block) if block
@@ -42,6 +47,8 @@ module ModelContextProtocol
         @prompts << entry
       when ->(ancestors) { ancestors.include?(ModelContextProtocol::Server::Resource) }
         @resources << entry
+      when ->(ancestors) { ancestors.include?(ModelContextProtocol::Server::ResourceTemplate) }
+        @resource_templates << entry
       when ->(ancestors) { ancestors.include?(ModelContextProtocol::Server::Tool) }
         @tools << entry
       else
@@ -58,6 +65,11 @@ module ModelContextProtocol
       entry ? entry[:klass] : nil
     end
 
+    def find_resource_template(uri)
+      entry = @resource_templates.find { |r| uri == r[:uriTemplate] }
+      entry ? entry[:klass] : nil
+    end
+
     def find_tool(name)
       find_by_name(@tools, name)
     end
@@ -70,6 +82,10 @@ module ModelContextProtocol
       ResourcesData[resources: @resources.map { |entry| entry.except(:klass) }]
     end
 
+    def resource_templates_data
+      ResourceTemplatesData[resource_templates: @resource_templates.map { |entry| entry.except(:klass, :completions) }]
+    end
+
     def tools_data
       ToolsData[tools: @tools.map { |entry| entry.except(:klass) }]
     end
@@ -88,6 +104,12 @@ module ModelContextProtocol
       end
     end
 
+    ResourceTemplatesData = Data.define(:resource_templates) do
+      def serialized
+        {resourceTemplates: resource_templates}
+      end
+    end
+
     ToolsData = Data.define(:tools) do
       def serialized
         {tools:}

data/lib/model_context_protocol/server/resource.rb

@@ -40,12 +40,13 @@ module ModelContextProtocol
       attr_reader :name, :description, :mime_type, :uri
 
       def with_metadata(&block)
-        metadata = instance_eval(&block)
+        metadata_dsl = MetadataDSL.new
+        metadata_dsl.instance_eval(&block)
 
-        @name = metadata[:name]
-        @description = metadata[:description]
-        @mime_type = metadata[:mime_type]
-        @uri = metadata[:uri]
+        @name = metadata_dsl.name
+        @description = metadata_dsl.description
+        @mime_type = metadata_dsl.mime_type
+        @uri = metadata_dsl.uri
       end
 
       def inherited(subclass)
@@ -60,7 +61,29 @@ module ModelContextProtocol
       end
 
       def metadata
-        {name: @name, description: @description, mime_type: @mime_type, uri: @uri}
+        {name: @name, description: @description, mimeType: @mime_type, uri: @uri}
+      end
+    end
+
+    class MetadataDSL
+      def name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def description(value = nil)
+        @description = value if value
+        @description
+      end
+
+      def mime_type(value = nil)
+        @mime_type = value if value
+        @mime_type
+      end
+
+      def uri(value = nil)
+        @uri = value if value
+        @uri
       end
     end
   end

data/lib/model_context_protocol/server/resource_template.rb

@@ -0,0 +1,93 @@
+module ModelContextProtocol
+  class Server::ResourceTemplate
+    class << self
+      attr_reader :name, :description, :mime_type, :uri_template, :completions
+
+      def with_metadata(&block)
+        metadata_dsl = MetadataDSL.new
+        metadata_dsl.instance_eval(&block)
+
+        @name = metadata_dsl.name
+        @description = metadata_dsl.description
+        @mime_type = metadata_dsl.mime_type
+        @uri_template = metadata_dsl.uri_template
+        @completions = metadata_dsl.completions
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@name, @name)
+        subclass.instance_variable_set(:@description, @description)
+        subclass.instance_variable_set(:@mime_type, @mime_type)
+        subclass.instance_variable_set(:@uri_template, @uri_template)
+        subclass.instance_variable_set(:@completions, @completions&.dup)
+      end
+
+      def complete_for(param_name, value)
+        completion = if @completions && @completions[param_name.to_s]
+          @completions[param_name.to_s]
+        else
+          ModelContextProtocol::Server::NullCompletion
+        end
+
+        completion.call(param_name.to_s, value)
+      end
+
+      def metadata
+        {
+          name: @name,
+          description: @description,
+          mimeType: @mime_type,
+          uriTemplate: @uri_template,
+          completions: @completions&.transform_keys(&:to_s)
+        }
+      end
+    end
+
+    class MetadataDSL
+      attr_reader :completions
+
+      def initialize
+        @completions = {}
+      end
+
+      def name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def description(value = nil)
+        @description = value if value
+        @description
+      end
+
+      def mime_type(value = nil)
+        @mime_type = value if value
+        @mime_type
+      end
+
+      def uri_template(value = nil, &block)
+        @uri_template = value if value
+
+        if block_given?
+          completion_dsl = CompletionDSL.new
+          completion_dsl.instance_eval(&block)
+          @completions = completion_dsl.completions
+        end
+
+        @uri_template
+      end
+    end
+
+    class CompletionDSL
+      attr_reader :completions
+
+      def initialize
+        @completions = {}
+      end
+
+      def completion(param_name, completion_class)
+        @completions[param_name.to_s] = completion_class
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/tool.rb

@@ -76,11 +76,12 @@ module ModelContextProtocol
       attr_reader :name, :description, :input_schema
 
       def with_metadata(&block)
-        metadata = instance_eval(&block)
+        metadata_dsl = MetadataDSL.new
+        metadata_dsl.instance_eval(&block)
 
-        @name = metadata[:name]
-        @description = metadata[:description]
-        @input_schema = metadata[:inputSchema]
+        @name = metadata_dsl.name
+        @description = metadata_dsl.description
+        @input_schema = metadata_dsl.input_schema
       end
 
       def inherited(subclass)
@@ -103,5 +104,22 @@ module ModelContextProtocol
         {name: @name, description: @description, inputSchema: @input_schema}
       end
     end
+
+    class MetadataDSL
+      def name(value = nil)
+        @name = value if value
+        @name
+      end
+
+      def description(value = nil)
+        @description = value if value
+        @description
+      end
+
+      def input_schema(&block)
+        @input_schema = instance_eval(&block) if block_given?
+        @input_schema
+      end
+    end
   end
 end

data/lib/model_context_protocol/server.rb

@@ -60,12 +60,45 @@ module ModelContextProtocol
         PingResponse[]
       end
 
+      router.map("completion/complete") do |message|
+        type = message["params"]["ref"]["type"]
+
+        completion_source = case type
+        when "ref/prompt"
+          name = message["params"]["ref"]["name"]
+          configuration.registry.find_prompt(name)
+        when "ref/resource"
+          uri = message["params"]["ref"]["uri"]
+          configuration.registry.find_resource_template(uri)
+        else
+          raise ModelContextProtocol::Server::ParameterValidationError, "ref/type invalid"
+        end
+
+        arg_name, arg_value = message["params"]["argument"].values_at("name", "value")
+
+        if completion_source
+          completion_source.complete_for(arg_name, arg_value)
+        else
+          ModelContextProtocol::Server::NullCompletion.call(arg_name, arg_value)
+        end
+      end
+
       router.map("resources/list") do
         configuration.registry.resources_data
       end
 
       router.map("resources/read") do |message|
-        configuration.registry.find_resource(message["params"]["uri"]).call
+        uri = message["params"]["uri"]
+        resource = configuration.registry.find_resource(uri)
+        unless resource
+          raise ModelContextProtocol::Server::ParameterValidationError, "resource not found for #{uri}"
+        end
+
+        resource.call
+      end
+
+      router.map("resources/templates/list") do |message|
+        configuration.registry.resource_templates_data
       end
 
       router.map("prompts/list") do
@@ -87,6 +120,7 @@ module ModelContextProtocol
 
     def build_capabilities
       {}.tap do |capabilities|
+        capabilities[:completions] = {}
         capabilities[:logging] = {} if configuration.logging_enabled?
 
         registry = configuration.registry
@@ -94,7 +128,7 @@ module ModelContextProtocol
         if registry.prompts_options.any? && !registry.instance_variable_get(:@prompts).empty?
           capabilities[:prompts] = {
             listChanged: registry.prompts_options[:list_changed]
-          }.compact
+          }.except(:completions).compact
         end
 
         if registry.resources_options.any? && !registry.instance_variable_get(:@resources).empty?

data/lib/model_context_protocol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ModelContextProtocol
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/model_context_protocol.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+require "addressable/template"
 
 Dir[File.join(__dir__, "model_context_protocol/", "**", "*.rb")].sort.each { |file| require_relative file }
 

data/tasks/templates/dev.erb

@@ -19,6 +19,10 @@ server = ModelContextProtocol::Server.new do |config|
       register TestBinaryResource
     end
 
+    resource_templates do
+      register TestResourceTemplate
+    end
+
     tools list_changed: true do
       register TestToolWithTextResponse
       register TestToolWithImageResponse

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-05 00:00:00.000000000 Z
+date: 2025-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-schema
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 description:
 email:
 - dick@hey.com
@@ -42,10 +56,12 @@ files:
 - Rakefile
 - lib/model_context_protocol.rb
 - lib/model_context_protocol/server.rb
+- lib/model_context_protocol/server/completion.rb
 - lib/model_context_protocol/server/configuration.rb
 - lib/model_context_protocol/server/prompt.rb
 - lib/model_context_protocol/server/registry.rb
 - lib/model_context_protocol/server/resource.rb
+- lib/model_context_protocol/server/resource_template.rb
 - lib/model_context_protocol/server/router.rb
 - lib/model_context_protocol/server/stdio_transport.rb
 - lib/model_context_protocol/server/tool.rb