actionmcp 0.55.2 → 0.60.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3347c3ede8a67c1b428c9f6a5e0f6d2f9f465b2e5105ae7f87e523b0af5b01ee
-  data.tar.gz: 3ccb75d093be9e4f8aad07a4a5fd09e4b37e67dabb50ad61a38d53bfdfd33882
+  metadata.gz: 2384a0cea84e17ca34e3c46e4029e2dc008561ebeeb8e52f15cb05c3fb5f5eb4
+  data.tar.gz: ccba3d9432ae0be54a4950e2f5d357c55fdd39cec2766253e2b3093dba9eedd8
 SHA512:
-  metadata.gz: cec3c090e5ce988fc94b10ad58f361aad563deac598907b9a711a5e4ab52a5ac7e661e7969de2ec65f5849278032bd2671a2d5457400716840fb6cebba7e2388
-  data.tar.gz: f1a8f3961ceefab410615e013a65e6b5cb11cc2427599ff2a8b697c1cd04d9d1cb8398e35b9ac63b98c579530cfe7c48f108703ecca65d4fb915c6c20f505367
+  metadata.gz: e7ed0c8b71d4211dc48388a7544c17ecb9ff674faad9274cd1225cb3e3a65f76bcb546c2c2353882a1ade9016670659fed38aa1c90aa94e17479149012e1be01
+  data.tar.gz: add51e3d310ec89d96bef2767008bc4be9f9bddfeda60ca826d6e9168485771ebf61c03e1011c889d0a57fb4ff3d7bb0e0f5c5046cb35ca69a5285d647fe71d2

data/README.md

@@ -22,6 +22,12 @@ This means an AI (like an LLM) can request information or actions from your appl
 
 **ActionMCP** is targeted at developers building MCP-enabled Rails applications. It simplifies the process of integrating Ruby and Rails apps with the MCP standard by providing a set of base classes and an easy-to-use server interface.
 
+## Protocol Support
+
+ActionMCP supports **MCP 2025-06-18** (current) with backward compatibility for **MCP 2025-03-26**. For a detailed (and entertaining) breakdown of protocol versions, features, and our design decisions, see [The Hitchhiker's Guide to MCP](The_Hitchhikers_Guide_to_MCP.md).
+
+*Don't Panic: The guide contains everything you need to know about surviving MCP protocol versions.*
+
 > **Note:** STDIO transport is not supported in ActionMCP. This gem is focused on production-ready, network-based deployments. STDIO is only suitable for desktop or script-based experimentation and is intentionally excluded.
 
 Instead of implementing MCP support from scratch, you can subclass and configure the provided **Prompt**, **Tool**, and **ResourceTemplate** classes to expose your app's functionality to LLMs. 
@@ -42,7 +48,16 @@ To start using ActionMCP, add it to your project:
   $ bundle add actionmcp
   ```
 
-This will load the ActionMCP library so you can start defining MCP prompts, tools, and resources in your application.
+After adding the gem, run the install generator to set up the basic ActionMCP structure:
+
+```bash
+bundle install
+bin/rails action_mcp:install:migrations
+bin/rails db:migrate
+bin/rails generate action_mcp:install
+```
+
+This will create the base application classes, configuration file, and necessary database tables for ActionMCP to function properly.
 
 ## Core Components
 
@@ -291,22 +306,23 @@ production:
   max_queue: 500      # Maximum number of tasks that can be queued
 ```
 
-#### SolidCable (Database-backed, Recommended)
+#### SolidMCP (Database-backed, Recommended)
 
-For SolidCable, add it to your Gemfile:
+For SolidMCP, add it to your Gemfile:
 
 ```ruby
-gem "solid_cable"  # Database-backed adapter (no Redis needed)
+gem "solid_mcp"  # Database-backed adapter optimized for MCP
 ```
 
 Then install it:
 
 ```bash
 bundle install
-bin/rails solid_cable:install
+bin/rails solid_mcp:install:migrations
+bin/rails db:migrate
 ```
 
-The installer will create the necessary database migration. You'll need to configure it in your `config/mcp.yml`. You can create this file with `bin/rails g action_mcp:config`.
+The installer will create the necessary database migration for message storage. Configure it in your `config/mcp.yml`.
 
 #### Redis Adapter
 
@@ -617,6 +633,33 @@ run ActionMCP::Engine
 bin/rails s -c mcp.ru -p 62770 -P tmp/pids/mcps0.pid
 ```
 
+### Dealing with Middleware Conflicts
+
+If your Rails application uses middleware that interferes with MCP server operation (like Devise, Warden, Ahoy, Rack::Cors, etc.), use `mcp_vanilla.ru` instead:
+
+```ruby
+# mcp_vanilla.ru - A minimal Rack app with only essential middleware
+# This avoids conflicts with authentication, tracking, and other web-specific middleware
+# See the file for detailed documentation on when and why to use it
+
+bundle exec rails s -c mcp_vanilla.ru -p 62770
+# Or with Falcon:
+bundle exec falcon serve --bind http://0.0.0.0:62770 --config mcp_vanilla.ru
+```
+
+Common middleware that can cause issues:
+- **Devise/Warden** - Expects cookies and sessions, throws `Devise::MissingWarden` errors
+- **Ahoy** - Analytics tracking that intercepts requests
+- **Rack::Attack** - Rate limiting designed for web traffic
+- **Rack::Cors** - CORS headers meant for browsers
+- Any middleware assuming HTML responses or cookie-based authentication
+
+An example of a minimal `mcp_vanilla.ru` file is located in the dummy app : test/dummy/mcp_vanilla.ru. 
+This file is a minimal Rack application that only includes the essential middleware needed for MCP server operation, avoiding conflicts with web-specific middleware.
+But remember to add any instrumentation or logging middleware you need, as the minimal setup will not include them by default.
+
+```ruby
+
 ## Production Deployment of MCPS0
 
 In production, **MCPS0** (the MCP server) is a standard Rack application. You can run it using any Rack-compatible server (such as Puma, Unicorn, or Passenger). 
@@ -631,7 +674,7 @@ Run MCPS0 on its own TCP port (commonly `62770`):
 
 **With Falcon:**
 ```bash
-bundle exec falcon serve --bind http://0.0.0.0:62770 mcp.ru
+bundle exec falcon serve --bind http://0.0.0.0:62770 --config mcp.ru
 ```
 
 **With Puma:**

data/app/controllers/action_mcp/application_controller.rb

@@ -4,16 +4,13 @@ module ActionMCP
   # Implements the MCP endpoints according to the 2025-03-26 specification.
   # Supports GET for server-initiated SSE streams, POST for client messages
   # (responding with JSON or SSE), and optionally DELETE for session termination.
-  class ApplicationController < ActionController::Metal
-    REQUIRED_PROTOCOL_VERSION = "2025-03-26"
+  class ApplicationController < ActionController::API
     MCP_SESSION_ID_HEADER = "Mcp-Session-Id"
 
-    ActionController::API.without_modules(:StrongParameters, :ParamsWrapper).each do |left|
-      include left
-    end
     include Engine.routes.url_helpers
     include JSONRPC_Rails::ControllerHelpers
     include ActionController::Live
+    include ActionController::Instrumentation
 
     # Provides the ActionMCP::Session for the current request.
     # Handles finding existing sessions via header/param or initializing a new one.
@@ -56,6 +53,8 @@ module ActionMCP
       response.headers["X-Accel-Buffering"] = "no"
       response.headers["Cache-Control"] = "no-cache"
       response.headers["Connection"] = "keep-alive"
+      # Add MCP-Protocol-Version header for established sessions
+      response.headers["MCP-Protocol-Version"] = session.protocol_version
 
       Rails.logger.info "Unified SSE (GET): Starting stream for session: #{session.id}"
 
@@ -97,7 +96,13 @@ module ActionMCP
       heartbeat_sender = lambda do
         if connection_active.true? && !response.stream.closed?
           begin
-            future = Concurrent::Promises.future { write_sse_event(sse, session, { type: "ping" }) }
+            # Send a proper JSON-RPC notification for heartbeat
+            ping_notification = {
+              jsonrpc: "2.0",
+              method: "notifications/ping",
+              params: {}
+            }
+            future = Concurrent::Promises.future { write_sse_event(sse, session, ping_notification) }
             future.value!(5)
             if heartbeat_active.true?
               heartbeat_task = Concurrent::ScheduledTask.execute(heartbeat_interval, &heartbeat_sender)
@@ -137,19 +142,34 @@ module ActionMCP
     # Handles POST requests containing client JSON-RPC messages according to 2025-03-26 spec.
     # @route POST /mcp
     def create
-      return render_not_acceptable(post_accept_headers_error_message) unless post_accept_headers_valid?
+      unless post_accept_headers_valid?
+        id = extract_jsonrpc_id_from_params
+        return render_not_acceptable(post_accept_headers_error_message, id)
+      end
+
+      # Reject JSON-RPC batch requests as per MCP 2025-06-18 spec
+      if jsonrpc_params_batch?
+        return render_bad_request("JSON-RPC batch requests are not supported", nil)
+      end
 
       is_initialize_request = check_if_initialize_request(jsonrpc_params)
       session_initially_missing = extract_session_id.nil?
       session = mcp_session
 
+      # Validate MCP-Protocol-Version header for non-initialize requests
+      # Temporarily disabled to debug session issues
+      # return unless validate_protocol_version_header
+
       unless is_initialize_request
         if session_initially_missing
-          return render_bad_request("Mcp-Session-Id header is required for this request.")
+          id = jsonrpc_params.respond_to?(:id) ? jsonrpc_params.id : nil
+          return render_bad_request("Mcp-Session-Id header is required for this request.", id)
         elsif session.nil? || session.new_record?
-          return render_not_found("Session not found.")
+          id = jsonrpc_params.respond_to?(:id) ? jsonrpc_params.id : nil
+          return render_not_found("Session not found.", id)
         elsif session.status == "closed"
-          return render_not_found("Session has been terminated.")
+          id = jsonrpc_params.respond_to?(:id) ? jsonrpc_params.id : nil
+          return render_not_found("Session has been terminated.", id)
         end
       end
 
@@ -173,7 +193,8 @@ module ActionMCP
       end
     rescue StandardError => e
       Rails.logger.error "Unified POST Error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
-      render_internal_server_error("An unexpected error occurred.") unless performed?
+      id = jsonrpc_params.respond_to?(:id) ? jsonrpc_params.id : nil rescue nil
+      render_internal_server_error("An unexpected error occurred.", id) unless performed?
     end
 
     # Handles DELETE requests for session termination (2025-03-26 spec).
@@ -201,24 +222,50 @@ module ActionMCP
 
     private
 
+    # Validates the MCP-Protocol-Version header for non-initialize requests
+    # Returns true if valid, renders error and returns false if invalid
+    def validate_protocol_version_header
+      # Skip validation for initialize requests
+      return true if check_if_initialize_request(jsonrpc_params)
+
+      header_version = request.headers["MCP-Protocol-Version"]
+      session = mcp_session
+
+      # If header is missing, assume 2025-03-26 for backward compatibility
+      if header_version.nil?
+        Rails.logger.debug "MCP-Protocol-Version header missing, assuming 2025-03-26 for backward compatibility"
+        return true
+      end
+
+      # Check if the header version is supported
+      unless ActionMCP::SUPPORTED_VERSIONS.include?(header_version)
+        render_bad_request("Unsupported MCP-Protocol-Version: #{header_version}")
+        return false
+      end
+
+      # If we have an initialized session, check if the header matches the negotiated version
+      if session && session.initialized?
+        negotiated_version = session.protocol_version
+        if header_version != negotiated_version
+          Rails.logger.warn "MCP-Protocol-Version mismatch: header=#{header_version}, negotiated=#{negotiated_version}"
+          render_bad_request("MCP-Protocol-Version header (#{header_version}) does not match negotiated version (#{negotiated_version})")
+          return false
+        end
+      end
+
+      true
+    end
+
     # Finds an existing session based on header or param, or initializes a new one.
     # Note: This doesn't save the new session; that happens upon first use or explicitly.
     def find_or_initialize_session
       session_id = extract_session_id
       if session_id
         session = Server.session_store.load_session(session_id)
-        if session
-          if ActionMCP.configuration.vibed_ignore_version
-            if session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
-              session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
-            end
-          elsif session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
-            session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
-          end
-        end
+        # Session protocol version is set during initialization and should not be overridden
         session
       else
-        Server.session_store.create_session(nil, protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
+        Server.session_store.create_session(nil, protocol_version: ActionMCP::DEFAULT_PROTOCOL_VERSION)
       end
     end
 
@@ -289,6 +336,10 @@ module ActionMCP
     # Renders the JSON-RPC response(s) as a direct JSON HTTP response.
     def render_json_response(payload, session, add_session_header)
       response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
+      # Add MCP-Protocol-Version header if session has been initialized
+      if session && session.initialized?
+        response.headers["MCP-Protocol-Version"] = session.protocol_version
+      end
       response.headers["Content-Type"] = "application/json"
       render json: payload, status: :ok
     end
@@ -296,6 +347,10 @@ module ActionMCP
     # Renders the JSON-RPC response(s) as an SSE stream.
     def render_sse_response(payload, session, add_session_header)
       response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
+      # Add MCP-Protocol-Version header if session has been initialized
+      if session && session.initialized?
+        response.headers["MCP-Protocol-Version"] = session.protocol_version
+      end
       response.headers["Content-Type"] = "text/event-stream"
       response.headers["X-Accel-Buffering"] = "no"
       response.headers["Cache-Control"] = "no-cache"
@@ -316,9 +371,18 @@ module ActionMCP
     # Also stores the event for potential resumability.
     def write_sse_event(sse, session, payload)
       event_id = session.increment_sse_counter!
-      data = payload.is_a?(String) ? payload : MultiJson.dump(payload)
-      sse_event = "id: #{event_id}\ndata: #{data}\n\n"
-      sse.write(sse_event)
+      # Ensure we're always writing valid JSON strings
+      data = case payload
+      when String
+               payload
+      when Hash
+               MultiJson.dump(payload)
+      else
+               MultiJson.dump(payload.to_h)
+      end
+      # Use the SSE class's write method with proper options
+      # According to MCP spec, we need to send with event type "message"
+      sse.write(data, event: "message", id: event_id)
 
       begin
         session.store_sse_event(event_id, payload, session.max_stored_sse_events)
@@ -346,33 +410,58 @@ module ActionMCP
     # --- Error Rendering Methods ---
 
     # Renders a 400 Bad Request response with a JSON-RPC-like error structure.
-    def render_bad_request(message = "Bad Request")
-      render json: { jsonrpc: "2.0", error: { code: -32_600, message: message } }
+    def render_bad_request(message = "Bad Request", id = nil)
+      id ||= extract_jsonrpc_id_from_request
+      render json: { jsonrpc: "2.0", id: id, error: { code: -32_600, message: message } }
     end
 
     # Renders a 404 Not Found response with a JSON-RPC-like error structure.
-    def render_not_found(message = "Not Found")
-      render json: { jsonrpc: "2.0", error: { code: -32_001, message: message } }
+    def render_not_found(message = "Not Found", id = nil)
+      id ||= extract_jsonrpc_id_from_request
+      render json: { jsonrpc: "2.0", id: id, error: { code: -32_001, message: message } }
     end
 
     # Renders a 405 Method Not Allowed response.
-    def render_method_not_allowed(message = "Method Not Allowed")
-      render json: { jsonrpc: "2.0", error: { code: -32_601, message: message } }
+    def render_method_not_allowed(message = "Method Not Allowed", id = nil)
+      id ||= extract_jsonrpc_id_from_request
+      render json: { jsonrpc: "2.0", id: id, error: { code: -32_601, message: message } }
     end
 
     # Renders a 406 Not Acceptable response.
-    def render_not_acceptable(message = "Not Acceptable")
-      render json: { jsonrpc: "2.0", error: { code: -32_002, message: message } }
+    def render_not_acceptable(message = "Not Acceptable", id = nil)
+      id ||= extract_jsonrpc_id_from_request
+      render json: { jsonrpc: "2.0", id: id, error: { code: -32_002, message: message } }
     end
 
     # Renders a 501 Not Implemented response.
-    def render_not_implemented(message = "Not Implemented")
-      render json: { jsonrpc: "2.0", error: { code: -32_003, message: message } }
+    def render_not_implemented(message = "Not Implemented", id = nil)
+      id ||= extract_jsonrpc_id_from_request
+      render json: { jsonrpc: "2.0", id: id, error: { code: -32_003, message: message } }
     end
 
     # Renders a 500 Internal Server Error response.
     def render_internal_server_error(message = "Internal Server Error", id = nil)
       render json: { jsonrpc: "2.0", id: id, error: { code: -32_000, message: message } }
     end
+
+    # Extract JSON-RPC ID from request
+    def extract_jsonrpc_id_from_request
+      # Try to get from already parsed jsonrpc_params first
+      if defined?(jsonrpc_params) && jsonrpc_params
+        return jsonrpc_params.respond_to?(:id) ? jsonrpc_params.id : nil
+      end
+
+      # Otherwise try to parse from raw body, this need refactoring
+      return nil unless request.post? && request.content_type&.include?("application/json")
+
+      begin
+        body = request.body.read
+        request.body.rewind # Reset for subsequent reads
+        json = JSON.parse(body)
+        json["id"]
+      rescue JSON::ParserError, StandardError
+        nil
+      end
+    end
   end
 end

data/app/models/action_mcp/session.rb

@@ -75,7 +75,7 @@ module ActionMCP
     before_create :set_server_info, if: -> { role == "server" }
     before_create :set_server_capabilities, if: -> { role == "server" }
 
-    validates :protocol_version, inclusion: { in: SUPPORTED_VERSIONS }, allow_nil: true, unless: lambda {
+    validates :protocol_version, inclusion: { in: ActionMCP::SUPPORTED_VERSIONS }, allow_nil: true, unless: lambda {
       ActionMCP.configuration.vibed_ignore_version
     }
 
@@ -130,7 +130,7 @@ module ActionMCP
 
     def server_capabilities_payload
       {
-        protocolVersion: PROTOCOL_VERSION,
+        protocolVersion: protocol_version || ActionMCP::DEFAULT_PROTOCOL_VERSION,
         serverInfo: server_info,
         capabilities: server_capabilities
       }

data/db/migrate/20250608112101_add_oauth_to_sessions.rb

@@ -5,15 +5,15 @@ class AddOAuthToSessions < ActiveRecord::Migration[8.0]
     # Use json for all databases (PostgreSQL, SQLite3, MySQL) for consistency
     json_type = :json
 
-    add_column :action_mcp_sessions, :oauth_access_token, :string
-    add_column :action_mcp_sessions, :oauth_refresh_token, :string
-    add_column :action_mcp_sessions, :oauth_token_expires_at, :datetime
-    add_column :action_mcp_sessions, :oauth_user_context, json_type
-    add_column :action_mcp_sessions, :authentication_method, :string, default: "none"
+    add_column :action_mcp_sessions, :oauth_access_token, :string unless column_exists?(:action_mcp_sessions, :oauth_access_token)
+    add_column :action_mcp_sessions, :oauth_refresh_token, :string unless column_exists?(:action_mcp_sessions, :oauth_refresh_token)
+    add_column :action_mcp_sessions, :oauth_token_expires_at, :datetime unless column_exists?(:action_mcp_sessions, :oauth_token_expires_at)
+    add_column :action_mcp_sessions, :oauth_user_context, json_type unless column_exists?(:action_mcp_sessions, :oauth_user_context)
+    add_column :action_mcp_sessions, :authentication_method, :string, default: "none" unless column_exists?(:action_mcp_sessions, :authentication_method)
 
     # Add indexes for performance
-    add_index :action_mcp_sessions, :oauth_access_token, unique: true
-    add_index :action_mcp_sessions, :oauth_token_expires_at
-    add_index :action_mcp_sessions, :authentication_method
+    add_index :action_mcp_sessions, :oauth_access_token, unique: true unless index_exists?(:action_mcp_sessions, :oauth_access_token)
+    add_index :action_mcp_sessions, :oauth_token_expires_at unless index_exists?(:action_mcp_sessions, :oauth_token_expires_at)
+    add_index :action_mcp_sessions, :authentication_method unless index_exists?(:action_mcp_sessions, :authentication_method)
   end
 end

data/lib/action_mcp/client/base.rb

@@ -12,6 +12,7 @@ module ActionMCP
       include Prompts
       include Resources
       include Roots
+      include Elicitation
       include Logging
 
       attr_reader :logger, :transport,
@@ -179,7 +180,7 @@ module ActionMCP
         end
 
         params = {
-          protocolVersion: PROTOCOL_VERSION,
+          protocolVersion: ActionMCP::DEFAULT_PROTOCOL_VERSION,
           capabilities: client_capabilities,
           clientInfo: client_info
         }

data/lib/action_mcp/client/elicitation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Handles elicitation requests from servers
+    module Elicitation
+      # Process elicitation request from server
+      # @param id [String, Integer] The request ID
+      # @param params [Hash] The elicitation parameters
+      def process_elicitation_request(id, params)
+        message = params["message"]
+        requested_schema = params["requestedSchema"]
+
+        # In a real implementation, this would prompt the user
+        # For now, we'll just return a decline response
+        # Actual implementations should override this method
+        send_jsonrpc_response(id, result: {
+          action: "decline"
+        })
+      end
+
+      # Send elicitation response
+      # @param id [String, Integer] The request ID
+      # @param action [String] The action taken ("accept", "decline", "cancel")
+      # @param content [Hash, nil] The form data if action is "accept"
+      def send_elicitation_response(id, action:, content: nil)
+        result = { action: action }
+        result[:content] = content if action == "accept" && content
+
+        send_jsonrpc_response(id, result: result)
+      end
+    end
+  end
+end

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -50,7 +50,19 @@ module ActionMCP
       # @param id [String, Integer]
       # @param params [Hash]
       def handle_method(rpc_method, id, params)
-        puts "\e[31mUnknown server method: #{rpc_method} #{id} #{params}\e[0m"
+        case rpc_method
+        when Methods::ELICITATION_CREATE
+          client.process_elicitation_request(id, params)
+        when /^roots\//
+          process_roots(rpc_method, id)
+        when /^sampling\//
+          process_sampling(rpc_method, id, params)
+        else
+          common_result = handle_common_methods(rpc_method, id, params)
+          if common_result.nil?
+            puts "\e[31mUnknown server method: #{rpc_method} #{id} #{params}\e[0m"
+          end
+        end
       end
 
       # @param rpc_method [String]
@@ -168,7 +180,7 @@ module ActionMCP
           # Create a new session with the server-provided ID
           client.instance_variable_set(:@session, ActionMCP::Session.from_client.new(
             id: session_id,
-            protocol_version: result["protocolVersion"] || PROTOCOL_VERSION,
+            protocol_version: result["protocolVersion"] || ActionMCP::DEFAULT_PROTOCOL_VERSION,
             client_info: client.client_info,
             client_capabilities: client.client_capabilities,
             server_info: result["serverInfo"],

data/lib/action_mcp/configuration.rb

@@ -25,6 +25,7 @@ module ActionMCP
                   :logging_level,
                   :active_profile,
                   :profiles,
+                  :elicitation_enabled,
                   # --- Authentication Options ---
                   :authentication_methods,
                   :oauth_config,
@@ -56,6 +57,7 @@ module ActionMCP
       @list_changed = false
       @logging_level = :info
       @resources_subscribe = false
+      @elicitation_enabled = false
       @active_profile = :primary
       @profiles = default_profiles
 
@@ -65,7 +67,7 @@ module ActionMCP
 
       @sse_heartbeat_interval = 30
       @post_response_preference = :json
-      @protocol_version = "2025-03-26"
+      @protocol_version = "2025-03-26"  # Default to legacy for backwards compatibility
       @vibed_ignore_version = false
 
       # Resumability defaults
@@ -186,6 +188,8 @@ module ActionMCP
 
       capabilities[:resources] = { subscribe: @resources_subscribe } if filtered_resources.any?
 
+      capabilities[:elicitation] = {} if @elicitation_enabled
+
       capabilities
     end
 
@@ -269,6 +273,11 @@ module ActionMCP
         @connects_to = app_config["connects_to"]
       end
 
+      # Extract session store configuration
+      if app_config["session_store_type"]
+        @session_store_type = app_config["session_store_type"].to_sym
+      end
+
       # Extract client and server session store types
       if app_config["client_session_store_type"]
         @client_session_store_type = app_config["client_session_store_type"].to_sym

data/lib/action_mcp/content/resource_link.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Content
+    # ResourceLink represents a link to a resource that the server is capable of reading.
+    # It's included in a prompt or tool call result.
+    # Note: resource links returned by tools are not guaranteed to appear in resources/list requests.
+    class ResourceLink < Base
+      # @return [String] The URI of the resource.
+      # @return [String, nil] The name of the resource (optional).
+      # @return [String, nil] The description of the resource (optional).
+      # @return [String, nil] The MIME type of the resource (optional).
+      attr_reader :uri, :name, :description, :mime_type
+
+      # Initializes a new ResourceLink content.
+      #
+      # @param uri [String] The URI of the resource.
+      # @param name [String, nil] The name of the resource (optional).
+      # @param description [String, nil] The description of the resource (optional).
+      # @param mime_type [String, nil] The MIME type of the resource (optional).
+      # @param annotations [Hash, nil] Optional annotations for the resource link.
+      def initialize(uri, name: nil, description: nil, mime_type: nil, annotations: nil)
+        super("resource_link", annotations: annotations)
+        @uri = uri
+        @name = name
+        @description = description
+        @mime_type = mime_type
+      end
+
+      # Returns a hash representation of the resource link content.
+      #
+      # @return [Hash] The hash representation of the resource link content.
+      def to_h
+        result = super.merge(uri: @uri)
+        result[:name] = @name if @name
+        result[:description] = @description if @description
+        result[:mimeType] = @mime_type if @mime_type
+        result
+      end
+    end
+  end
+end

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -28,6 +28,9 @@ module ActionMCP
       # Notification methods
       NOTIFICATIONS_INITIALIZED = "notifications/initialized"
       NOTIFICATIONS_CANCELLED = "notifications/cancelled"
+
+      # Elicitation methods
+      ELICITATION_CREATE = "elicitation/create"
     end
 
     delegate :initialize!, :initialized?, to: :transport

data/lib/action_mcp/prompt.rb

@@ -6,6 +6,7 @@ module ActionMCP
     include ActionMCP::Callbacks
     include ActionMCP::CurrentHelpers
     class_attribute :_argument_definitions, instance_accessor: false, default: []
+    class_attribute :_meta, instance_accessor: false, default: {}
 
     # ---------------------------------------------------
     # Prompt Name
@@ -35,6 +36,16 @@ module ActionMCP
       def type
         :prompt
       end
+
+      # Sets or retrieves the _meta field
+      def meta(data = nil)
+        if data
+          raise ArgumentError, "_meta must be a hash" unless data.is_a?(Hash)
+          self._meta = _meta.merge(data)
+        else
+          _meta
+        end
+      end
     end
 
     # ---------------------------------------------------
@@ -80,11 +91,16 @@ module ActionMCP
     # ---------------------------------------------------
     # @return [Hash] The prompt definition as a Hash.
     def self.to_h
-      {
+      result = {
         name: prompt_name,
         description: description.presence,
         arguments: arguments.map { |arg| arg.slice(:name, :description, :required, :type) }
       }.compact
+
+      # Add _meta if present
+      result[:_meta] = _meta if _meta.any?
+
+      result
     end
 
     # ---------------------------------------------------