Internal Release 0.4.0

- Added support for handle_json method from JSON RPC gem to allow consumers to pass JSON strings
- Added context parameter to prompt templating system

- Updated tool and prompt registration to use class references instead of instances
- Changed tool response is_error to isError to match protocol specification

Author: topherbullock

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    model_context_protocol (0.3.0)
+    model_context_protocol (0.4.0)
       json_rpc_handler (~> 0.1)
 
 GEM

README.md

@@ -46,11 +46,31 @@ module ModelContextProtocol
     def index
       server = ModelContextProtocol::Server.new(
         name: "my_server",
-        tools: [someTool, anotherTool],
-        prompts: [myPrompt],
-        context: nil,
+        tools: [SomeTool, AnotherTool],
+        prompts: [MyPrompt],
+        context: { user_id: current_user.id },
       )
-      render(json: server.handle(request.body.read).to_h)
+      render(json: server.handle_json(request.body.read).to_h)
+    end
+  end
+end
+```
+
+or, if you want/need to parse the json yourself you can do the following
+
+```ruby
+module ModelContextProtocol
+  class ApplicationController < ActionController::Base
+
+    sig { void }
+    def index
+      server = ModelContextProtocol::Server.new(
+        name: "my_server",
+        tools: [SomeTool, AnotherTool],
+        prompts: [MyPrompt],
+        context: { user_id: current_user.id },
+      )
+      render(json: server.handle(JSON.parse(request.body.read)).to_h)
     end
   end
 end
@@ -77,16 +97,19 @@ end
 ### Exception Reporting
 
 The exception reporter receives two arguments:
+
 - `exception`: The Ruby exception object that was raised
 - `context`: A hash containing contextual information about where the error occurred
 
 The context hash includes:
+
 - For tool calls: `{ tool_name: "name", arguments: { ... } }`
 - For general request handling: `{ request: { ... } }`
 
 When an exception occurs:
+
 1. The exception is reported via the configured reporter
-2. For tool calls, a generic error response is returned to the client: `{ error: "Internal error occurred", is_error: true }`
+2. For tool calls, a generic error response is returned to the client: `{ error: "Internal error occurred", isError: true }`
 3. For other requests, the exception is re-raised after reporting
 
 If no exception reporter is configured, a default no-op reporter is used that silently ignores exceptions.
@@ -104,12 +127,12 @@ class MyTool < ModelContextProtocol::Tool
   description "This tool performs specific functionality..."
   input_schema [{ type: "text", name: "message" }]
 
-  def call(message, context:)
+  def self.call(message, context:)
     Tool::Response.new([{ type: "text", content: "OK" }])
   end
 end
 
-tool = MyTool.new
+tool = MyTool
 ```
 
 2. By using the `ModelContextProtocol::Tool.define` method with a block:
@@ -143,22 +166,26 @@ class MyPrompt < ModelContextProtocol::Prompt
     )
   ]
 
-  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"])
-        )
-      ]
-    )
+  class << self
+    def template(args, context:)
+      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
 end
+
+prompt = MyPrompt
 ```
 
 2. Using the `ModelContextProtocol::Prompt.define` method:
@@ -174,7 +201,7 @@ prompt = ModelContextProtocol::Prompt.define(
       required: true
     )
   ]
-) do |args|
+) do |args, context:|
   Prompt::Result.new(
     description: "Response description",
     messages: [
@@ -191,6 +218,9 @@ prompt = ModelContextProtocol::Prompt.define(
 end
 ```
 
+The context parameter is the context passed into the server and can be used to pass per request information,
+e.g. around authentication state or user preferences.
+
 ### Key Components
 
 - `Prompt::Argument` - Defines input parameters for the prompt template
@@ -205,8 +235,8 @@ Register prompts with the MCP server:
 ```ruby
 server = ModelContextProtocol::Server.new(
   name: "my_server",
-  prompts: [MyPrompt.new],
-  context: nil,
+  prompts: [MyPrompt],
+  context: { user_id: current_user.id },
 )
 ```
 

lib/model_context_protocol/prompt.rb

@@ -45,68 +45,77 @@ def to_h
     end
 
     class << self
+      NOT_SET = Object.new
+
       attr_reader :description_value
       attr_reader :arguments_value
 
+      def template(args, context:)
+        raise NotImplementedError, "Subclasses must implement template"
+      end
+
+      def to_h
+        { name: name_value, description: description_value, arguments: arguments_value.map(&:to_h) }.compact
+      end
+
       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
+      def prompt_name(value = NOT_SET)
+        if value == NOT_SET
+          @name_value
+        else
+          @name_value = value
+        end
       end
 
       def name_value
         @name_value || StringUtils.handle_from_class_name(name)
       end
 
-      def description(value)
-        @description_value = value
+      def description(value = NOT_SET)
+        if value == NOT_SET
+          @description_value
+        else
+          @description_value = value
+        end
       end
 
-      def arguments(value)
-        @arguments_value = value
+      def arguments(value = NOT_SET)
+        if value == NOT_SET
+          @arguments_value
+        else
+          @arguments_value = value
+        end
       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)
+        Class.new(self) do
+          prompt_name name
+          description description
+          arguments arguments
+          define_singleton_method(:template) do |args, context:|
+            instance_exec(args, context:, &block)
           end
         end
       end
-    end
 
-    attr_reader :name, :description, :arguments
+      def validate_arguments!(args)
+        missing = required_args - args.keys
+        return if missing.empty?
 
-    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)
-      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
-      { name:, description:, arguments: arguments.map(&:to_h) }.compact
-    end
+        raise ArgumentError, "Missing required arguments: #{missing.join(", ")}"
+      end
 
-    private
+      private
 
-    def required_args
-      arguments.filter_map { |arg| arg.name if arg.required }
+      def required_args
+        arguments_value.filter_map { |arg| arg.name if arg.required }
+      end
     end
   end
 end

lib/model_context_protocol/server.rb

@@ -20,8 +20,8 @@ def initialize(message, request)
 
     def initialize(name: "model_context_protocol", tools: [], prompts: [], resources: [], context: nil)
       @name = name
-      @tools = tools.to_h { |t| [t.name, t] }
-      @prompts = prompts.to_h { |p| [p.name, p] }
+      @tools = tools.to_h { |t| [t.name_value, t] }
+      @prompts = prompts.to_h { |p| [p.name_value, p] }
       @resources = resources
       @resource_index = resources.index_by(&:uri)
       @context = context
@@ -39,21 +39,13 @@ def initialize(name: "model_context_protocol", tools: [], prompts: [], resources
 
     def handle(request)
       JsonRpcHandler.handle(request) do |method|
-        instrument_call(method) do
-          case method
-          when "tools/list"
-            ->(params) { { tools: @handlers["tools/list"].call(params) } }
-          when "prompts/list"
-            ->(params) { { prompts: @handlers["prompts/list"].call(params) } }
-          when "resources/list"
-            ->(params) { { resources: @handlers["resources/list"].call(params) } }
-          else
-            @handlers[method]
-          end
-        rescue => e
-          report_exception(e, { request: request })
-          raise RequestHandlerError.new("Internal error handling #{request[:method]} request", request)
-        end
+        handle_request(request, method)
+      end
+    end
+
+    def handle_json(request)
+      JsonRpcHandler.handle_json(request) do |method|
+        handle_request(request, method)
       end
     end
 
@@ -83,6 +75,24 @@ def prompts_get_handler(&block)
 
     private
 
+    def handle_request(request, method)
+      instrument_call(method) do
+        case method
+        when "tools/list"
+          ->(params) { { tools: @handlers["tools/list"].call(params) } }
+        when "prompts/list"
+          ->(params) { { prompts: @handlers["prompts/list"].call(params) } }
+        when "resources/list"
+          ->(params) { { resources: @handlers["resources/list"].call(params) } }
+        else
+          @handlers[method]
+        end
+      rescue => e
+        report_exception(e, { request: request })
+        raise RequestHandlerError.new("Internal error handling #{request[:method]} request", request)
+      end
+    end
+
     def capabilities
       @capabilities ||= {
         prompts: {},
@@ -152,7 +162,7 @@ def get_prompt(request)
       prompt_args = request[:arguments]
       prompt.validate_arguments!(prompt_args)
 
-      prompt.template(prompt_args).to_h
+      prompt.template(prompt_args, context:).to_h
     end
 
     def list_resources(request)
@@ -172,7 +182,6 @@ def read_resource(request)
       end
 
       add_instrumentation_data(resource_uri:)
-
       resource.to_h
     end