Internal Release 0.2.0

- fix `lib/mcp-ruby` auto-import path
- implement server resources
- add basic listing of resources to Server
- allow setting handlers on Server
- wrap handler method results
- make tool definition more declarative
- make prompt definition more declarative
- bump dependency versions

Author: topherbullock

.rubocop.yml

@@ -1,2 +1,5 @@
 inherit_gem:
   rubocop-shopify: rubocop.yml
+Naming/FileName:
+  Exclude:
+    - 'lib/mcp-ruby.rb'

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    model_context_protocol (0.1.1)
+    model_context_protocol (0.2.2)
       activesupport
 
 GEM

README.md

@@ -59,43 +59,117 @@ end
 
 MCP spec includes [Tools](https://modelcontextprotocol.io/docs/concepts/tools) which provide functionality to LLM apps.
 
-This gem provides a `ModelContextProtocol::Tool` class that can be instantiated to create tools.
+This gem provides a `ModelContextProtocol::Tool` class that can be used to create tools in two ways:
 
-Tools can be passed into the `ModelContextProtocol::Server` constructor to register them with the server.
+1. As a class definition:
+```ruby
+class MyTool < ModelContextProtocol::Tool
+  tool_name "my_tool"
+  tool_description "This tool performs specific functionality..."
+  tool_input_schema [{ type: "text", name: "message" }]
 
-### Example Tool Implementation
+  def call(message)
+    Tool::Response.new([{ type: "text", content: "OK" }])
+  end
+end
 
-The `Tool` class allows creating tools that can be used within the model context.
-To create a tool, instantiate the class with the required parameters and an optional block:
+tool = MyTool.new
+```
 
+2. By using the `ModelContextProtocol::Tool.define` method with a block:
 ```ruby
-tool = ModelContextProtocol::Tool.new(name: "my_tool", description: "This tool performs specific functionality...") do |args|
-  # Implement the tool's functionality here
-  result = process_something(args["parameter_name"])
-  ModelContextProtocol::Tool::Response.new([{ type: "text", text: result }], false )
+tool = ModelContextProtocol::Tool.define(name: "my_tool", description: "This tool performs specific functionality...") do |args|
+  Tool::Response.new([{ type: "text", content: "OK" }])
 end
 ```
 
 ## Prompts
 
-MCP spec includes
-[Prompts](https://modelcontextprotocol.io/docs/concepts/prompts), `Prompts` enable servers to define reusable prompt
-templates and workflows that clients can easily surface to users and LLMs
+MCP spec includes [Prompts](https://modelcontextprotocol.io/docs/concepts/prompts), which enable servers to define reusable prompt templates and workflows that clients can easily surface to users and LLMs.
 
-The `Prompt` class allows creating prompts that can be used within the model context.
+The `ModelContextProtocol::Prompt` class provides two ways to create prompts:
 
-To create a prompt, instantiate the class with the required parameters and an optional block:
+1. As a class definition with metadata:
+```ruby
+class MyPrompt < ModelContextProtocol::Prompt
+  prompt_name "my_prompt"  # Optional - defaults to underscored class name
+  description "This prompt performs specific functionality..."
+  arguments [
+    Prompt::Argument.new(
+      name: "message",
+      description: "Input message",
+      required: true
+    )
+  ]
+
+  def template(args)
+    Prompt::Result.new(
+      description: "Response description",
+      messages: [
+        Prompt::Message.new(
+          role: "user",
+          content: Content::Text.new("User message")
+        ),
+        Prompt::Message.new(
+          role: "assistant",
+          content: Content::Text.new(args["message"])
+        )
+      ]
+    )
+  end
+end
+```
 
+2. Using the `ModelContextProtocol::Prompt.define` method:
 ```ruby
-prompt = ModelContextProtocol::Prompt.new(name: "my_prompt", description: "This prompt performs specific functionality...") do |args|
-  # Implement the prompt's functionality here
-  result = template_something(args["parameter_name"])
-  ModelContextProtocol::Prompt::Response.new([{ type: "text", text: result }], false )
+prompt = ModelContextProtocol::Prompt.define(
+  name: "my_prompt",
+  description: "This prompt performs specific functionality...",
+  arguments: [
+    Prompt::Argument.new(
+      name: "message",
+      description: "Input message",
+      required: true
+    )
+  ]
+) do |args|
+  Prompt::Result.new(
+    description: "Response description",
+    messages: [
+      Prompt::Message.new(
+        role: "user",
+        content: Content::Text.new("User message")
+      ),
+      Prompt::Message.new(
+        role: "assistant",
+        content: Content::Text.new(args["message"])
+      )
+    ]
+  )
 end
 ```
 
+### Key Components
+
+- `Prompt::Argument` - Defines input parameters for the prompt template
+- `Prompt::Message` - Represents a message in the conversation with a role and content
+- `Prompt::Result` - The output of a prompt template containing description and messages
+- `Content::Text` - Text content for messages
+
+### Usage
+
+Register prompts with the MCP server:
 
+```ruby
+server = ModelContextProtocol::Server.new(
+  name: "my_server",
+  prompts: [MyPrompt.new]
+)
+```
 
+The server will handle prompt listing and execution through the MCP protocol methods:
+- `prompts/list` - Lists all registered prompts and their schemas
+- `prompts/get` - Retrieves and executes a specific prompt with arguments
 
 ## Releases
 

lib/mcp-ruby.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "model_context_protocol"

lib/model_context_protocol.rb

@@ -7,6 +7,7 @@
 require "model_context_protocol/content"
 require "model_context_protocol/resource"
 require "model_context_protocol/prompt"
+require "model_context_protocol/version"
 
 module ModelContextProtocol
   class Annotations

lib/model_context_protocol/prompt.rb

@@ -44,19 +44,59 @@ def to_h
       end
     end
 
+    class << self
+      attr_reader :description_value
+      attr_reader :arguments_value
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@name_value, nil)
+        subclass.instance_variable_set(:@description_value, nil)
+        subclass.instance_variable_set(:@arguments_value, nil)
+      end
+
+      def prompt_name(value)
+        @name_value = value
+      end
+
+      def name_value
+        @name_value || name.demodulize.underscore
+      end
+
+      def description(value)
+        @description_value = value
+      end
+
+      def arguments(value)
+        @arguments_value = value
+      end
+
+      def define(name: nil, description: nil, arguments: [], &block)
+        new(name:, description:, arguments:).tap do |prompt|
+          prompt.define_singleton_method(:template) do |args|
+            instance_exec(args, &block)
+          end
+        end
+      end
+    end
+
     attr_reader :name, :description, :arguments
 
-    def initialize(name:, description: nil, arguments: [], &block)
-      @name = name
-      @description = description
-      @arguments = arguments
-      @template_block = block
+    def initialize(name: nil, description: nil, arguments: nil)
+      @name = name || self.class.name_value
+      @description = description || self.class.description_value
+      @arguments = arguments || self.class.arguments_value
     end
 
     def template(args)
-      validate_args!(args)
-      result = @template_block.call(args)
-      result
+      raise NotImplementedError, "Prompt subclasses must implement template"
+    end
+
+    def validate_arguments!(args)
+      missing = required_args - args.keys
+      return if missing.empty?
+
+      raise ArgumentError, "Missing required arguments: #{missing.join(", ")}"
     end
 
     def to_h
@@ -68,12 +108,5 @@ def to_h
     def required_args
       arguments.filter_map { |arg| arg.name if arg.required }
     end
-
-    def validate_args!(args)
-      missing = required_args - args.keys
-      return if missing.empty?
-
-      raise ArgumentError, "Missing required arguments: #{missing.join(", ")}"
-    end
   end
 end

lib/model_context_protocol/resource.rb

@@ -2,57 +2,25 @@
 # frozen_string_literal: true
 
 module ModelContextProtocol
-  module Resource
-    class Embedded
-      attr_reader :resource, :annotations
-
-      def initialize(resource:, annotations: nil)
-        @resource = resource
-        @annotations = annotations
-      end
-
-      def to_h
-        { resource: resource.to_h, annotations: }.compact
-      end
-    end
-
-    class Contents
-      attr_reader :uri, :mime_type
-
-      def initialize(uri:, mime_type: nil)
-        @uri = uri
-        @mime_type = mime_type
-      end
-
-      def to_h
-        { uri:, mime_type: }.compact
-      end
+  class Resource
+    attr_reader :uri, :name, :description, :mime_type, :contents
+
+    def initialize(uri:, name:, description:, mime_type:, contents:)
+      @uri = uri
+      @name = name
+      @description = description
+      @mime_type = mime_type
+      @contents = contents
     end
 
-    class TextContents < Contents
-      attr_reader :text
-
-      def initialize(text:, uri:, mime_type:)
-        super(uri: uri, mime_type: mime_type)
-        @text = text
-      end
-
-      def to_h
-        super.merge(text: text)
-      end
-    end
-
-    class BlobContents < Contents
-      attr_reader :data
-
-      def initialize(data:, uri:, mime_type:)
-        super(uri: uri, mime_type: mime_type)
-        @data = data
-      end
-
-      def to_h
-        super.merge(data: data)
-      end
+    def to_h
+      {
+        uri: @uri,
+        name: @name,
+        description: @description,
+        mimeType: @mime_type,
+        contents: @contents.map(&:to_h),
+      }
     end
   end
 end

lib/model_context_protocol/resource/contents.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  class Resource
+    class Contents
+      attr_reader :uri, :mime_type
+
+      def initialize(uri:, mime_type: nil)
+        @uri = uri
+        @mime_type = mime_type
+      end
+
+      def to_h
+        { uri:, mime_type: }.compact
+      end
+    end
+
+    class TextContents < Contents
+      attr_reader :text
+
+      def initialize(text:, uri:, mime_type:)
+        super(uri: uri, mime_type: mime_type)
+        @text = text
+      end
+
+      def to_h
+        super.merge(text: text)
+      end
+    end
+
+    class BlobContents < Contents
+      attr_reader :data
+
+      def initialize(data:, uri:, mime_type:)
+        super(uri: uri, mime_type: mime_type)
+        @data = data
+      end
+
+      def to_h
+        super.merge(data: data)
+      end
+    end
+  end
+end

lib/model_context_protocol/resource/embedded.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  class Resource
+    class Embedded
+      attr_reader :resource, :annotations
+
+      def initialize(resource:, annotations: nil)
+        @annotations = annotations
+      end
+
+      def to_h
+        { resource: resource.to_h, annotations: }.compact
+      end
+    end
+  end
+end